From 9cd5c0ec79b532621605072994d98f47a2867f62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Sun, 24 Jun 2018 16:56:00 +0200
Subject: [PATCH 001/116] test: add test for missing dynamic instantiate hook

PR-URL: https://github.com/nodejs/node/pull/21506
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 ...esm-loader-missing-dynamic-instantiate-hook.mjs | 14 ++++++++++++++
 .../missing-dynamic-instantiate-hook.mjs           |  6 ++++++
 2 files changed, 20 insertions(+)
 create mode 100644 test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
 create mode 100644 test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs

diff --git a/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs b/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
new file mode 100644
index 00000000000000..27447b3e436afe
--- /dev/null
+++ b/test/es-module/test-esm-loader-missing-dynamic-instantiate-hook.mjs
@@ -0,0 +1,14 @@
+// Flags: --experimental-modules --loader ./test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
+
+import {
+  crashOnUnhandledRejection,
+  expectsError
+} from '../common';
+
+crashOnUnhandledRejection();
+
+import('test').catch(expectsError({
+  code: 'ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
+  message: 'The ES Module loader may not return a format of \'dynamic\' ' +
+    'when no dynamicInstantiate function was provided'
+}));
diff --git a/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs b/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
new file mode 100644
index 00000000000000..6993747fcc0142
--- /dev/null
+++ b/test/fixtures/es-module-loaders/missing-dynamic-instantiate-hook.mjs
@@ -0,0 +1,6 @@
+export function resolve(specifier, parentModule, defaultResolver) {
+  if (specifier !== 'test') {
+    return defaultResolver(specifier, parentModule);
+  }
+  return { url: 'file://', format: 'dynamic' };
+}

From 96dae837137fb5352a274f4e6e833d20dd90c115 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 30 Jun 2018 14:58:19 +0200
Subject: [PATCH 002/116] zlib: fix memory leak for unused zlib instances
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An oversight in an earlier commit led to a memory leak
in the untypical situation that zlib instances are created
but never used, because zlib handles no longer started
out their life as weak handles.

The bug was introduced in bd201102862a194f3f5ce669e0a3c8143eafc900.

Refs: https://github.com/nodejs/node/pull/20455

PR-URL: https://github.com/nodejs/node/pull/21607
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
---
 src/node_zlib.cc                       |  1 +
 test/parallel/test-zlib-unused-weak.js | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 test/parallel/test-zlib-unused-weak.js

diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index de8b0335892f65..8e30241f4e6d45 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -90,6 +90,7 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
         refs_(0),
         gzip_id_bytes_read_(0),
         write_result_(nullptr) {
+    MakeWeak();
   }
 
 
diff --git a/test/parallel/test-zlib-unused-weak.js b/test/parallel/test-zlib-unused-weak.js
new file mode 100644
index 00000000000000..7a5a6728533e18
--- /dev/null
+++ b/test/parallel/test-zlib-unused-weak.js
@@ -0,0 +1,18 @@
+'use strict';
+// Flags: --expose-gc
+require('../common');
+const assert = require('assert');
+const zlib = require('zlib');
+
+// Tests that native zlib handles start out their life as weak handles.
+
+const before = process.memoryUsage().external;
+for (let i = 0; i < 100; ++i)
+  zlib.createGzip();
+const afterCreation = process.memoryUsage().external;
+global.gc();
+const afterGC = process.memoryUsage().external;
+
+assert((afterGC - before) / (afterCreation - before) <= 0.05,
+       `Expected after-GC delta ${afterGC - before} to be less than 5 %` +
+       ` of before-GC delta ${afterCreation - before}`);

From 3a627c830b15fd1c5ce9d8926991abf6772b8fb8 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 13 Jun 2018 14:01:33 -0400
Subject: [PATCH 003/116] src: add context-aware init macro and doc

Introduces macros `NODE_MODULE_INITIALIZER` which expands to the name
of the special symbol that process.dlopen() will look for to initialize
an addon, and `NODE_MODULE_INIT()` which creates the boilerplate for
a context-aware module which can be loaded multiple times via the
special symbol mechanism.

Additionally, provides an example of using the new macro to construct
an addon which stores per-addon-instance data in a heap-allocated
structure that gets passed to each binding, rather than in a collection
of global static variables.

Re: https://github.com/nodejs/node/issues/21291#issuecomment-396729727
PR-URL: https://github.com/nodejs/node/pull/21318
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
---
 doc/api/addons.md                  | 135 +++++++++++++++++++++++++++++
 src/node.h                         |  22 +++++
 test/addons/hello-world/binding.cc |  13 ++-
 3 files changed, 163 insertions(+), 7 deletions(-)

diff --git a/doc/api/addons.md b/doc/api/addons.md
index 578b1a0f90b4ce..9ea0a6b6446ce4 100644
--- a/doc/api/addons.md
+++ b/doc/api/addons.md
@@ -98,6 +98,140 @@ the `.node` suffix).
 In the `hello.cc` example, then, the initialization function is `Initialize`
 and the addon module name is `addon`.
 
+When building addons with `node-gyp`, using the macro `NODE_GYP_MODULE_NAME` as
+the first parameter of `NODE_MODULE()` will ensure that the name of the final
+binary will be passed to `NODE_MODULE()`.
+
+### Context-aware addons
+
+There are environments in which Node.js addons may need to be loaded multiple
+times in multiple contexts. For example, the [Electron][] runtime runs multiple
+instances of Node.js in a single process. Each instance will have its own
+`require()` cache, and thus each instance will need a native addon to behave
+correctly when loaded via `require()`. From the addon's perspective, this means
+that it must support multiple initializations.
+
+A context-aware addon can be constructed by using the macro
+`NODE_MODULE_INITIALIZER`, which expands to the name of a function which Node.js
+will expect to find when it loads an addon. An addon can thus be initialized as
+in the following example:
+
+```cpp
+using namespace v8;
+
+extern "C" NODE_MODULE_EXPORT void
+NODE_MODULE_INITIALIZER(Local<Object> exports,
+                        Local<Value> module,
+                        Local<Context> context) {
+  /* Perform addon initialization steps here. */
+}
+```
+
+Another option is to use the macro `NODE_MODULE_INIT()`, which will also
+construct a context-aware addon. Unlike `NODE_MODULE()`, which is used to
+construct an addon around a given addon initializer function,
+`NODE_MODULE_INIT()` serves as the declaration of such an initializer to be
+followed by a function body.
+
+The following three variables may be used inside the function body following an
+invocation of `NODE_MODULE_INIT()`:
+* `Local<Object> exports`,
+* `Local<Value> module`, and
+* `Local<Context> context`
+
+The choice to build a context-aware addon carries with it the responsibility of
+carefully managing global static data. Since the addon may be loaded multiple
+times, potentially even from different threads, any global static data stored
+in the addon must be properly protected, and must not contain any persistent
+references to JavaScript objects. The reason for this is that JavaScript
+objects are only valid in one context, and will likely cause a crash when
+accessed from the wrong context or from a different thread than the one on which
+they were created.
+
+The context-aware addon can be structured to avoid global static data by
+performing the following steps:
+* defining a class which will hold per-addon-instance data. Such
+a class should include a `v8::Persistent<v8::Object>` which will hold a weak
+reference to the addon's `exports` object. The callback associated with the weak
+reference will then destroy the instance of the class.
+* constructing an instance of this class in the addon initializer such that the
+`v8::Persistent<v8::Object>` is set to the `exports` object.
+* storing the instance of the class in a `v8::External`, and
+* passing the `v8::External` to all methods exposed to JavaScript by passing it
+to the `v8::FunctionTemplate` constructor which creates the native-backed
+JavaScript functions. The `v8::FunctionTemplate` constructor's third parameter
+accepts the `v8::External`.
+
+This will ensure that the per-addon-instance data reaches each binding that can
+be called from JavaScript. The per-addon-instance data must also be passed into
+any asynchronous callbacks the addon may create.
+
+The following example illustrates the implementation of a context-aware addon:
+
+```cpp
+#include <node.h>
+
+using namespace v8;
+
+class AddonData {
+ public:
+  AddonData(Isolate* isolate, Local<Object> exports):
+      call_count(0) {
+    // Link the existence of this object instance to the existence of exports.
+    exports_.Reset(isolate, exports);
+    exports_.SetWeak(this, DeleteMe, WeakCallbackType::kParameter);
+  }
+
+  ~AddonData() {
+    if (!exports_.IsEmpty()) {
+      // Reset the reference to avoid leaking data.
+      exports_.ClearWeak();
+      exports_.Reset();
+    }
+  }
+
+  // Per-addon data.
+  int call_count;
+
+ private:
+  // Method to call when "exports" is about to be garbage-collected.
+  static void DeleteMe(const WeakCallbackInfo<AddonData>& info) {
+    delete info.GetParameter();
+  }
+
+  // Weak handle to the "exports" object. An instance of this class will be
+  // destroyed along with the exports object to which it is weakly bound.
+  v8::Persistent<v8::Object> exports_;
+};
+
+static void Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  // Retrieve the per-addon-instance data.
+  AddonData* data =
+      reinterpret_cast<AddonData*>(info.Data().As<External>()->Value());
+  data->call_count++;
+  info.GetReturnValue().Set((double)data->call_count);
+}
+
+// Initialize this addon to be context-aware.
+NODE_MODULE_INIT(/* exports, module, context */) {
+  Isolate* isolate = context->GetIsolate();
+
+  // Create a new instance of AddonData for this instance of the addon.
+  AddonData* data = new AddonData(isolate, exports);
+  // Wrap the data in a v8::External so we can pass it to the method we expose.
+  Local<External> external = External::New(isolate, data);
+
+  // Expose the method "Method" to JavaScript, and make sure it receives the
+  // per-addon-instance data we created above by passing `external` as the
+  // third parameter to the FunctionTemplate constructor.
+  exports->Set(context,
+               String::NewFromUtf8(isolate, "method", NewStringType::kNormal)
+                  .ToLocalChecked(),
+               FunctionTemplate::New(isolate, Method, external)
+                  ->GetFunction(context).ToLocalChecked()).FromJust();
+}
+```
+
 ### Building
 
 Once the source code has been written, it must be compiled into the binary
@@ -1162,6 +1296,7 @@ Test in JavaScript by running:
 require('./build/Release/addon');
 ```
 
+[Electron]: https://electronjs.org/
 [Embedder's Guide]: https://github.com/v8/v8/wiki/Embedder's%20Guide
 [Linking to Node.js' own dependencies]: #addons_linking_to_node_js_own_dependencies
 [Native Abstractions for Node.js]: https://github.com/nodejs/nan
diff --git a/src/node.h b/src/node.h
index b551c8bb09baf9..ed2c074b922687 100644
--- a/src/node.h
+++ b/src/node.h
@@ -579,6 +579,28 @@ extern "C" NODE_EXTERN void node_module_register(void* mod);
  */
 #define NODE_MODULE_DECL /* nothing */
 
+#define NODE_MODULE_INITIALIZER_BASE node_register_module_v
+
+#define NODE_MODULE_INITIALIZER_X(base, version)                      \
+    NODE_MODULE_INITIALIZER_X_HELPER(base, version)
+
+#define NODE_MODULE_INITIALIZER_X_HELPER(base, version) base##version
+
+#define NODE_MODULE_INITIALIZER                                       \
+  NODE_MODULE_INITIALIZER_X(NODE_MODULE_INITIALIZER_BASE,             \
+      NODE_MODULE_VERSION)
+
+#define NODE_MODULE_INIT()                                            \
+  extern "C" NODE_MODULE_EXPORT void                                  \
+  NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,              \
+                          v8::Local<v8::Value> module,                \
+                          v8::Local<v8::Context> context);            \
+  NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME,                     \
+                            NODE_MODULE_INITIALIZER)                  \
+  void NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,         \
+                               v8::Local<v8::Value> module,           \
+                               v8::Local<v8::Context> context)
+
 /* Called after the event loop exits but before the VM is disposed.
  * Callbacks are run in reverse order of registration, i.e. newest first.
  */
diff --git a/test/addons/hello-world/binding.cc b/test/addons/hello-world/binding.cc
index e267a3b2a7629a..341b58f9a640d8 100644
--- a/test/addons/hello-world/binding.cc
+++ b/test/addons/hello-world/binding.cc
@@ -6,13 +6,12 @@ void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(v8::String::NewFromUtf8(isolate, "world"));
 }
 
-#define CONCAT(a, b) CONCAT_HELPER(a, b)
-#define CONCAT_HELPER(a, b) a##b
-#define INITIALIZER CONCAT(node_register_module_v, NODE_MODULE_VERSION)
-
-extern "C" NODE_MODULE_EXPORT void INITIALIZER(v8::Local<v8::Object> exports,
-                                               v8::Local<v8::Value> module,
-                                               v8::Local<v8::Context> context) {
+// Not using the full NODE_MODULE_INIT() macro here because we want to test the
+// addon loader's reaction to the FakeInit() entry point below.
+extern "C" NODE_MODULE_EXPORT void
+NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,
+                        v8::Local<v8::Value> module,
+                        v8::Local<v8::Context> context) {
   NODE_SET_METHOD(exports, "hello", Method);
 }
 

From 221c8bd58fa7b3277749bf39e43bd055dff1de67 Mon Sep 17 00:00:00 2001
From: Timothy Gu <timothygu99@gmail.com>
Date: Mon, 25 Jun 2018 00:48:48 -0400
Subject: [PATCH 004/116] messaging: use actual DOMException for DataCloneError

PR-URL: https://github.com/nodejs/node/pull/21540
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/bootstrap/node.js |  9 ++++
 lib/internal/domexception.js   | 83 ++++++++++++++++++++++++++++++++++
 node.gyp                       |  1 +
 src/env.h                      |  1 +
 src/node_messaging.cc          | 26 ++++++++++-
 5 files changed, 119 insertions(+), 1 deletion(-)
 create mode 100644 lib/internal/domexception.js

diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index d120d8ccae14e6..df5d667aeb7b39 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -101,6 +101,10 @@
       setupGlobalURL();
     }
 
+    if (process.binding('config').experimentalWorker) {
+      setupDOMException();
+    }
+
     // On OpenBSD process.execPath will be relative unless we
     // get the full path before process.execPath is used.
     if (process.platform === 'openbsd') {
@@ -381,6 +385,11 @@
     });
   }
 
+  function setupDOMException() {
+    // Registers the constructor with C++.
+    NativeModule.require('internal/domexception');
+  }
+
   function setupInspector(originalConsole, wrappedConsole, CJSModule) {
     if (!process.config.variables.v8_enable_inspector) {
       return;
diff --git a/lib/internal/domexception.js b/lib/internal/domexception.js
new file mode 100644
index 00000000000000..fe371e099eb17f
--- /dev/null
+++ b/lib/internal/domexception.js
@@ -0,0 +1,83 @@
+'use strict';
+
+const { internalBinding } = require('internal/bootstrap/loaders');
+const { registerDOMException } = internalBinding('messaging');
+const { ERR_INVALID_THIS } = require('internal/errors').codes;
+
+const internalsMap = new WeakMap();
+
+const nameToCodeMap = new Map();
+
+class DOMException extends Error {
+  constructor(message = '', name = 'Error') {
+    super();
+    internalsMap.set(this, {
+      message: `${message}`,
+      name: `${name}`
+    });
+  }
+
+  get name() {
+    const internals = internalsMap.get(this);
+    if (internals === undefined) {
+      throw new ERR_INVALID_THIS('DOMException');
+    }
+    return internals.name;
+  }
+
+  get message() {
+    const internals = internalsMap.get(this);
+    if (internals === undefined) {
+      throw new ERR_INVALID_THIS('DOMException');
+    }
+    return internals.message;
+  }
+
+  get code() {
+    const internals = internalsMap.get(this);
+    if (internals === undefined) {
+      throw new ERR_INVALID_THIS('DOMException');
+    }
+    const code = nameToCodeMap.get(internals.name);
+    return code === undefined ? 0 : code;
+  }
+}
+
+for (const [name, codeName, value] of [
+  ['IndexSizeError', 'INDEX_SIZE_ERR', 1],
+  ['DOMStringSizeError', 'DOMSTRING_SIZE_ERR', 2],
+  ['HierarchyRequestError', 'HIERARCHY_REQUEST_ERR', 3],
+  ['WrongDocumentError', 'WRONG_DOCUMENT_ERR', 4],
+  ['InvalidCharacterError', 'INVALID_CHARACTER_ERR', 5],
+  ['NoDataAllowedError', 'NO_DATA_ALLOWED_ERR', 6],
+  ['NoModificationAllowedError', 'NO_MODIFICATION_ALLOWED_ERR', 7],
+  ['NotFoundError', 'NOT_FOUND_ERR', 8],
+  ['NotSupportedError', 'NOT_SUPPORTED_ERR', 9],
+  ['InUseAttributeError', 'INUSE_ATTRIBUTE_ERR', 10],
+  ['InvalidStateError', 'INVALID_STATE_ERR', 11],
+  ['SyntaxError', 'SYNTAX_ERR', 12],
+  ['InvalidModificationError', 'INVALID_MODIFICATION_ERR', 13],
+  ['NamespaceError', 'NAMESPACE_ERR', 14],
+  ['InvalidAccessError', 'INVALID_ACCESS_ERR', 15],
+  ['ValidationError', 'VALIDATION_ERR', 16],
+  ['TypeMismatchError', 'TYPE_MISMATCH_ERR', 17],
+  ['SecurityError', 'SECURITY_ERR', 18],
+  ['NetworkError', 'NETWORK_ERR', 19],
+  ['AbortError', 'ABORT_ERR', 20],
+  ['URLMismatchError', 'URL_MISMATCH_ERR', 21],
+  ['QuotaExceededError', 'QUOTA_EXCEEDED_ERR', 22],
+  ['TimeoutError', 'TIMEOUT_ERR', 23],
+  ['InvalidNodeTypeError', 'INVALID_NODE_TYPE_ERR', 24],
+  ['DataCloneError', 'DATA_CLONE_ERR', 25]
+  // There are some more error names, but since they don't have codes assigned,
+  // we don't need to care about them.
+]) {
+  const desc = { enumerable: true, value };
+  Object.defineProperty(DOMException, codeName, desc);
+  Object.defineProperty(DOMException.prototype, codeName, desc);
+  nameToCodeMap.set(name, value);
+}
+
+module.exports = DOMException;
+
+registerDOMException(DOMException);
diff --git a/node.gyp b/node.gyp
index 300a20b6e306c4..207c72cdb56a29 100644
--- a/node.gyp
+++ b/node.gyp
@@ -106,6 +106,7 @@
       'lib/internal/constants.js',
       'lib/internal/dns/promises.js',
       'lib/internal/dns/utils.js',
+      'lib/internal/domexception.js',
       'lib/internal/encoding.js',
       'lib/internal/errors.js',
       'lib/internal/error-serdes.js',
diff --git a/src/env.h b/src/env.h
index 6c759c84e7685d..c7e75004bf0ceb 100644
--- a/src/env.h
+++ b/src/env.h
@@ -322,6 +322,7 @@ struct PackageConfig {
   V(buffer_prototype_object, v8::Object)                                      \
   V(context, v8::Context)                                                     \
   V(domain_callback, v8::Function)                                            \
+  V(domexception_function, v8::Function)                                      \
   V(fdclose_constructor_template, v8::ObjectTemplate)                         \
   V(fd_constructor_template, v8::ObjectTemplate)                              \
   V(filehandlereadwrap_template, v8::ObjectTemplate)                          \
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index be37cd39c366d0..7ddd3c4165c511 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -144,6 +144,21 @@ void Message::AddMessagePort(std::unique_ptr<MessagePortData>&& data) {
 
 namespace {
 
+void ThrowDataCloneError(Environment* env, Local<String> message) {
+  Local<Value> argv[] = {
+    message,
+    FIXED_ONE_BYTE_STRING(env->isolate(), "DataCloneError")
+  };
+  Local<Value> exception;
+  Local<Function> domexception_ctor = env->domexception_function();
+  CHECK(!domexception_ctor.IsEmpty());
+  if (!domexception_ctor->NewInstance(env->context(), arraysize(argv), argv)
+          .ToLocal(&exception)) {
+    return;
+  }
+  env->isolate()->ThrowException(exception);
+}
+
 // This tells V8 how to serialize objects that it does not understand
 // (e.g. C++ objects) into the output buffer, in a way that our own
 // DeserializerDelegate understands how to unpack.
@@ -153,7 +168,7 @@ class SerializerDelegate : public ValueSerializer::Delegate {
       : env_(env), context_(context), msg_(m) {}
 
   void ThrowDataCloneError(Local<String> message) override {
-    env_->isolate()->ThrowException(Exception::Error(message));
+    ThrowDataCloneError(env_, message);
   }
 
   Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {
@@ -688,6 +703,13 @@ static void MessageChannel(const FunctionCallbackInfo<Value>& args) {
       .FromJust();
 }
 
+static void RegisterDOMException(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK_EQ(args.Length(), 1);
+  CHECK(args[0]->IsFunction());
+  env->set_domexception_function(args[0].As<Function>());
+}
+
 static void InitMessaging(Local<Object> target,
                           Local<Value> unused,
                           Local<Context> context,
@@ -708,6 +730,8 @@ static void InitMessaging(Local<Object> target,
               env->message_port_constructor_string(),
               GetMessagePortConstructor(env, context).ToLocalChecked())
                   .FromJust();
+
+  env->SetMethod(target, "registerDOMException", RegisterDOMException);
 }
 
 }  // anonymous namespace

From ed774b7930f699119f36d6afa23b4e9e6c35aa6a Mon Sep 17 00:00:00 2001
From: Timothy Gu <timothygu99@gmail.com>
Date: Sun, 24 Jun 2018 23:10:37 -0400
Subject: [PATCH 005/116] messaging: fix edge cases with transferring ports

Currently, transferring the port on which postMessage is called causes a
segmentation fault, and transferring the target port causes a subsequent
port.onmessage setting to throw, or a deadlock if onmessage is set
before the postMessage. Fix both of these behaviors and align the
methods more closely with the normative definitions in the HTML
Standard.

Also, per spec postMessage must not throw just because the ports are
disentangled. Implement that behavior.

PR-URL: https://github.com/nodejs/node/pull/21540
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_messaging.cc                         | 99 ++++++++++++++-----
 src/node_messaging.h                          | 31 +++++-
 ...est-worker-message-port-transfer-closed.js | 54 ++++++++++
 .../test-worker-message-port-transfer-self.js | 33 +++++++
 ...est-worker-message-port-transfer-target.js | 24 +++++
 5 files changed, 213 insertions(+), 28 deletions(-)
 create mode 100644 test/parallel/test-worker-message-port-transfer-closed.js
 create mode 100644 test/parallel/test-worker-message-port-transfer-self.js
 create mode 100644 test/parallel/test-worker-message-port-transfer-target.js

diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 7ddd3c4165c511..712add06d3e2bc 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -144,7 +144,7 @@ void Message::AddMessagePort(std::unique_ptr<MessagePortData>&& data) {
 
 namespace {
 
-void ThrowDataCloneError(Environment* env, Local<String> message) {
+void ThrowDataCloneException(Environment* env, Local<String> message) {
   Local<Value> argv[] = {
     message,
     FIXED_ONE_BYTE_STRING(env->isolate(), "DataCloneError")
@@ -168,7 +168,7 @@ class SerializerDelegate : public ValueSerializer::Delegate {
       : env_(env), context_(context), msg_(m) {}
 
   void ThrowDataCloneError(Local<String> message) override {
-    ThrowDataCloneError(env_, message);
+    ThrowDataCloneException(env_, message);
   }
 
   Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {
@@ -239,7 +239,8 @@ class SerializerDelegate : public ValueSerializer::Delegate {
 Maybe<bool> Message::Serialize(Environment* env,
                                Local<Context> context,
                                Local<Value> input,
-                               Local<Value> transfer_list_v) {
+                               Local<Value> transfer_list_v,
+                               Local<Object> source_port) {
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(context);
 
@@ -273,8 +274,23 @@ Maybe<bool> Message::Serialize(Environment* env,
         continue;
       } else if (env->message_port_constructor_template()
                     ->HasInstance(entry)) {
+        // Check if the source MessagePort is being transferred.
+        if (!source_port.IsEmpty() && entry == source_port) {
+          ThrowDataCloneException(
+              env,
+              FIXED_ONE_BYTE_STRING(env->isolate(),
+                                    "Transfer list contains source port"));
+          return Nothing<bool>();
+        }
         MessagePort* port = Unwrap<MessagePort>(entry.As<Object>());
-        CHECK_NE(port, nullptr);
+        if (port == nullptr || port->IsDetached()) {
+          ThrowDataCloneException(
+              env,
+              FIXED_ONE_BYTE_STRING(
+                  env->isolate(),
+                  "MessagePort in transfer list is already detached"));
+          return Nothing<bool>();
+        }
         delegate.ports_.push_back(port);
         continue;
       }
@@ -410,6 +426,10 @@ uv_async_t* MessagePort::async() {
   return reinterpret_cast<uv_async_t*>(GetHandle());
 }
 
+bool MessagePort::IsDetached() const {
+  return data_ == nullptr || IsHandleClosing();
+}
+
 void MessagePort::TriggerAsync() {
   if (IsHandleClosing()) return;
   CHECK_EQ(uv_async_send(async()), 0);
@@ -552,36 +572,69 @@ std::unique_ptr<MessagePortData> MessagePort::Detach() {
 }
 
 
-void MessagePort::Send(Message&& message) {
-  Mutex::ScopedLock lock(*data_->sibling_mutex_);
-  if (data_->sibling_ == nullptr)
-    return;
-  data_->sibling_->AddToIncomingQueue(std::move(message));
-}
+Maybe<bool> MessagePort::PostMessage(Environment* env,
+                                     Local<Value> message_v,
+                                     Local<Value> transfer_v) {
+  Isolate* isolate = env->isolate();
+  Local<Object> obj = object(isolate);
+  Local<Context> context = obj->CreationContext();
 
-void MessagePort::Send(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = object(env->isolate())->CreationContext();
   Message msg;
-  if (msg.Serialize(env, context, args[0], args[1])
-          .IsNothing()) {
-    return;
+
+  // Per spec, we need to both check if transfer list has the source port, and
+  // serialize the input message, even if the MessagePort is closed or detached.
+
+  Maybe<bool> serialization_maybe =
+      msg.Serialize(env, context, message_v, transfer_v, obj);
+  if (data_ == nullptr) {
+    return serialization_maybe;
+  }
+  if (serialization_maybe.IsNothing()) {
+    return Nothing<bool>();
+  }
+
+  Mutex::ScopedLock lock(*data_->sibling_mutex_);
+  bool doomed = false;
+
+  // Check if the target port is posted to itself.
+  if (data_->sibling_ != nullptr) {
+    for (const auto& port_data : msg.message_ports()) {
+      if (data_->sibling_ == port_data.get()) {
+        doomed = true;
+        ProcessEmitWarning(env, "The target port was posted to itself, and "
+                                "the communication channel was lost");
+        break;
+      }
+    }
   }
-  Send(std::move(msg));
+
+  if (data_->sibling_ == nullptr || doomed)
+    return Just(true);
+
+  data_->sibling_->AddToIncomingQueue(std::move(msg));
+  return Just(true);
 }
 
 void MessagePort::PostMessage(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  MessagePort* port;
-  ASSIGN_OR_RETURN_UNWRAP(&port, args.This());
-  if (!port->data_) {
-    return THROW_ERR_CLOSED_MESSAGE_PORT(env);
-  }
   if (args.Length() == 0) {
     return THROW_ERR_MISSING_ARGS(env, "Not enough arguments to "
                                        "MessagePort.postMessage");
   }
-  port->Send(args);
+
+  MessagePort* port = Unwrap<MessagePort>(args.This());
+  // Even if the backing MessagePort object has already been deleted, we still
+  // want to serialize the message to ensure spec-compliant behavior w.r.t.
+  // transfers.
+  if (port == nullptr) {
+    Message msg;
+    Local<Object> obj = args.This();
+    Local<Context> context = obj->CreationContext();
+    USE(msg.Serialize(env, context, args[0], args[1], obj));
+    return;
+  }
+
+  port->PostMessage(env, args[0], args[1]);
 }
 
 void MessagePort::Start() {
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 28122c526cccea..62ae633b9e0b8d 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -32,10 +32,14 @@ class Message {
   // Serialize a JS value, and optionally transfer objects, into this message.
   // The Message object retains ownership of all transferred objects until
   // deserialization.
+  // The source_port parameter, if provided, will make Serialize() throw a
+  // "DataCloneError" DOMException if source_port is found in transfer_list.
   v8::Maybe<bool> Serialize(Environment* env,
                             v8::Local<v8::Context> context,
                             v8::Local<v8::Value> input,
-                            v8::Local<v8::Value> transfer_list);
+                            v8::Local<v8::Value> transfer_list,
+                            v8::Local<v8::Object> source_port =
+                                v8::Local<v8::Object>());
 
   // Internal method of Message that is called when a new SharedArrayBuffer
   // object is encountered in the incoming value's structure.
@@ -44,6 +48,13 @@ class Message {
   // and that transfers ownership of `data` to this message.
   void AddMessagePort(std::unique_ptr<MessagePortData>&& data);
 
+  // The MessagePorts that will be transferred, as recorded by Serialize().
+  // Used for warning user about posting the target MessagePort to itself,
+  // which will as a side effect destroy the communication channel.
+  const std::vector<std::unique_ptr<MessagePortData>>& message_ports() const {
+    return message_ports_;
+  }
+
  private:
   MallocedBuffer<char> main_message_buf_;
   std::vector<MallocedBuffer<char>> array_buffer_contents_;
@@ -122,10 +133,11 @@ class MessagePort : public HandleWrap {
                           std::unique_ptr<MessagePortData> data = nullptr);
 
   // Send a message, i.e. deliver it into the sibling's incoming queue.
-  // If there is no sibling, i.e. this port is closed,
-  // this message is silently discarded.
-  void Send(Message&& message);
-  void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // If this port is closed, or if there is no sibling, this message is
+  // serialized with transfers, then silently discarded.
+  v8::Maybe<bool> PostMessage(Environment* env,
+                              v8::Local<v8::Value> message,
+                              v8::Local<v8::Value> transfer);
   // Deliver a single message into this port's incoming queue.
   void AddToIncomingQueue(Message&& message);
 
@@ -157,6 +169,15 @@ class MessagePort : public HandleWrap {
   void Close(
       v8::Local<v8::Value> close_callback = v8::Local<v8::Value>()) override;
 
+  // Returns true if either data_ has been freed, or if the handle is being
+  // closed. Equivalent to the [[Detached]] internal slot in the HTML Standard.
+  //
+  // If checking if a JavaScript MessagePort object is detached, this method
+  // alone is often not enough, since the backing C++ MessagePort object may
+  // have been deleted already. For all intents and purposes, an object with a
+  // NULL pointer to the C++ MessagePort object is also detached.
+  inline bool IsDetached() const;
+
   size_t self_size() const override;
 
  private:
diff --git a/test/parallel/test-worker-message-port-transfer-closed.js b/test/parallel/test-worker-message-port-transfer-closed.js
new file mode 100644
index 00000000000000..435a3789fca724
--- /dev/null
+++ b/test/parallel/test-worker-message-port-transfer-closed.js
@@ -0,0 +1,54 @@
+// Flags: --experimental-worker
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { MessageChannel } = require('worker_threads');
+
+// This tests various behaviors around transferring MessagePorts with closing
+// or closed handles.
+
+const { port1, port2 } = new MessageChannel();
+
+const arrayBuf = new ArrayBuffer(10);
+port1.onmessage = common.mustNotCall();
+port2.onmessage = common.mustNotCall();
+
+function testSingle(closedPort, potentiallyOpenPort) {
+  assert.throws(common.mustCall(() => {
+    potentiallyOpenPort.postMessage(null, [arrayBuf, closedPort]);
+  }), common.mustCall((err) => {
+    assert.strictEqual(err.name, 'DataCloneError');
+    assert.strictEqual(err.message,
+                       'MessagePort in transfer list is already detached');
+    assert.strictEqual(err.code, 25);
+    assert.ok(err instanceof Error);
+
+    const DOMException = err.constructor;
+    assert.ok(err instanceof DOMException);
+    assert.strictEqual(DOMException.name, 'DOMException');
+
+    return true;
+  }));
+
+  // arrayBuf must not be transferred, even though it is present earlier in the
+  // transfer list than the closedPort.
+  assert.strictEqual(arrayBuf.byteLength, 10);
+}
+
+function testBothClosed() {
+  testSingle(port1, port2);
+  testSingle(port2, port1);
+}
+
+// Even though the port handles may not be completely closed in C++ land, the
+// observable behavior must be that the closing/detachment is synchronous and
+// instant.
+
+port1.close(common.mustCall(testBothClosed));
+testSingle(port1, port2);
+port2.close(common.mustCall(testBothClosed));
+testBothClosed();
+
+setTimeout(common.mustNotCall('The communication channel is still open'),
+           common.platformTimeout(1000)).unref();
diff --git a/test/parallel/test-worker-message-port-transfer-self.js b/test/parallel/test-worker-message-port-transfer-self.js
new file mode 100644
index 00000000000000..1855023cdfae04
--- /dev/null
+++ b/test/parallel/test-worker-message-port-transfer-self.js
@@ -0,0 +1,33 @@
+// Flags: --experimental-worker
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { MessageChannel } = require('worker_threads');
+
+const { port1, port2 } = new MessageChannel();
+
+assert.throws(common.mustCall(() => {
+  port1.postMessage(null, [port1]);
+}), common.mustCall((err) => {
+  assert.strictEqual(err.name, 'DataCloneError');
+  assert.strictEqual(err.message, 'Transfer list contains source port');
+  assert.strictEqual(err.code, 25);
+  assert.ok(err instanceof Error);
+
+  const DOMException = err.constructor;
+  assert.ok(err instanceof DOMException);
+  assert.strictEqual(DOMException.name, 'DOMException');
+
+  return true;
+}));
+
+// The failed transfer should not affect the ports in anyway.
+port2.onmessage = common.mustCall((message) => {
+  assert.strictEqual(message, 2);
+  port1.close();
+
+  setTimeout(common.mustNotCall('The communication channel is still open'),
+             common.platformTimeout(1000)).unref();
+});
+port1.postMessage(2);
diff --git a/test/parallel/test-worker-message-port-transfer-target.js b/test/parallel/test-worker-message-port-transfer-target.js
new file mode 100644
index 00000000000000..8e6354d8269771
--- /dev/null
+++ b/test/parallel/test-worker-message-port-transfer-target.js
@@ -0,0 +1,24 @@
+// Flags: --experimental-worker
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { MessageChannel } = require('worker_threads');
+
+const { port1, port2 } = new MessageChannel();
+
+const arrayBuf = new ArrayBuffer(10);
+
+common.expectWarning('Warning',
+                     'The target port was posted to itself, and the ' +
+                     'communication channel was lost',
+                     common.noWarnCode);
+port2.onmessage = common.mustNotCall();
+port2.postMessage(null, [port1, arrayBuf]);
+
+// arrayBuf must be transferred, despite the fact that port2 never received the
+// message.
+assert.strictEqual(arrayBuf.byteLength, 0);
+
+setTimeout(common.mustNotCall('The communication channel is still open'),
+           common.platformTimeout(1000)).unref();

From fe9888a34a4367e90fe17d695d5ae1f555ce64da Mon Sep 17 00:00:00 2001
From: Masashi Hirano <cherrydog07@gmail.com>
Date: Mon, 2 Jul 2018 03:52:30 +0900
Subject: [PATCH 006/116] test: check type for Worker filename argument
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add test to check type for first argument of Worker to increase
coverage.

PR-URL: https://github.com/nodejs/node/pull/21620
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
---
 test/parallel/test-worker-type-check.js | 28 +++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 test/parallel/test-worker-type-check.js

diff --git a/test/parallel/test-worker-type-check.js b/test/parallel/test-worker-type-check.js
new file mode 100644
index 00000000000000..43013bc538712a
--- /dev/null
+++ b/test/parallel/test-worker-type-check.js
@@ -0,0 +1,28 @@
+// Flags: --experimental-worker
+'use strict';
+
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+{
+  [
+    undefined,
+    null,
+    false,
+    0,
+    Symbol('test'),
+    {},
+    [],
+    () => {}
+  ].forEach((val) => {
+    common.expectsError(
+      () => new Worker(val),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        type: TypeError,
+        message: 'The "filename" argument must be of type string. ' +
+                 `Received type ${typeof val}`
+      }
+    );
+  });
+}

From 25dac9516453cba3ba492abd301394ec4024f300 Mon Sep 17 00:00:00 2001
From: Haroon Khan <aitchkhan@gmail.com>
Date: Wed, 27 Jun 2018 18:51:53 +0500
Subject: [PATCH 007/116] test: fix args passed to strictEqual

The third argument passed to asert.strictEqual() displays the message
passed as third argument and does not report the difference between
actual and expected if the test is failing.
Hence, the third argument has been removed.

PR-URL: https://github.com/nodejs/node/pull/21584
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 test/parallel/test-timers-immediate-queue.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-timers-immediate-queue.js b/test/parallel/test-timers-immediate-queue.js
index 511a3adf864859..ba9ba87c4070bd 100644
--- a/test/parallel/test-timers-immediate-queue.js
+++ b/test/parallel/test-timers-immediate-queue.js
@@ -50,5 +50,5 @@ for (let i = 0; i < QUEUE; i++)
 
 process.on('exit', function() {
   console.log('hit', hit);
-  assert.strictEqual(hit, QUEUE, 'We ticked between the immediate queue');
+  assert.strictEqual(hit, QUEUE);
 });

From 6f8ebc08b9f7537f82f57f07c6911c176627722b Mon Sep 17 00:00:00 2001
From: Thomas Watson <w@tson.dk>
Date: Tue, 3 Jul 2018 10:56:29 +0200
Subject: [PATCH 008/116] doc: unify spelling of backpressure

PR-URL: https://github.com/nodejs/node/pull/21630
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 doc/api/stream.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index fe0eae32ed8417..7e7a3fb92a933d 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -637,7 +637,7 @@ state, attaching a listener for the `'data'` event, calling the
 `readable.readableFlowing` to `true`, causing the `Readable` to begin
 actively emitting events as data is generated.
 
-Calling `readable.pause()`, `readable.unpipe()`, or receiving "back pressure"
+Calling `readable.pause()`, `readable.unpipe()`, or receiving backpressure
 will cause the `readable.readableFlowing` to be set as `false`,
 temporarily halting the flowing of events but *not* halting the generation of
 data. While in this state, attaching a listener for the `'data'` event

From 4fa7150962621cc4d68640c37cbbb7967780b7a9 Mon Sep 17 00:00:00 2001
From: Timothy Gu <timothygu99@gmail.com>
Date: Sun, 24 Jun 2018 01:11:53 -0400
Subject: [PATCH 009/116] fs: support pseudofiles in promises.readFile

PR-URL: https://github.com/nodejs/node/pull/21497
Fixes: https://github.com/nodejs/node/issues/21331
Refs: http://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html
Refs: https://groups.google.com/forum/#!topic/nodejs-dev/rxZ_RoH1Gn0
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
---
 lib/internal/fs/promises.js                   | 17 +++----
 .../test-fs-promises-file-handle-readFile.js  | 17 +++++++
 test/parallel/test-fs-promises-readfile.js    | 44 +++++++++++++------
 3 files changed, 57 insertions(+), 21 deletions(-)

diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index befcccb2769589..e567bf0731b5c7 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -125,6 +125,10 @@ async function writeFileHandle(filehandle, data, options) {
   } while (remaining > 0);
 }
 
+// Note: This is different from kReadFileBufferLength used for non-promisified
+// fs.readFile.
+const kReadFileMaxChunkSize = 16384;
+
 async function readFileHandle(filehandle, options) {
   const statFields = await binding.fstat(filehandle.fd, false, kUsePromises);
 
@@ -135,22 +139,19 @@ async function readFileHandle(filehandle, options) {
     size = 0;
   }
 
-  if (size === 0)
-    return options.encoding ? '' : Buffer.alloc(0);
-
   if (size > kMaxLength)
     throw new ERR_FS_FILE_TOO_LARGE(size);
 
   const chunks = [];
-  const chunkSize = Math.min(size, 16384);
-  let totalRead = 0;
+  const chunkSize = size === 0 ?
+    kReadFileMaxChunkSize :
+    Math.min(size, kReadFileMaxChunkSize);
   let endOfFile = false;
   do {
     const buf = Buffer.alloc(chunkSize);
     const { bytesRead, buffer } =
-      await read(filehandle, buf, 0, chunkSize, totalRead);
-    totalRead += bytesRead;
-    endOfFile = bytesRead !== chunkSize;
+      await read(filehandle, buf, 0, chunkSize, -1);
+    endOfFile = bytesRead === 0;
     if (bytesRead > 0)
       chunks.push(buffer.slice(0, bytesRead));
   } while (!endOfFile);
diff --git a/test/parallel/test-fs-promises-file-handle-readFile.js b/test/parallel/test-fs-promises-file-handle-readFile.js
index 316fd6581fa446..9e6fcc2784c49d 100644
--- a/test/parallel/test-fs-promises-file-handle-readFile.js
+++ b/test/parallel/test-fs-promises-file-handle-readFile.js
@@ -28,5 +28,22 @@ async function validateReadFile() {
   assert.deepStrictEqual(buffer, readFileData);
 }
 
+async function validateReadFileProc() {
+  // Test to make sure reading a file under the /proc directory works. Adapted
+  // from test-fs-read-file-sync-hostname.js.
+  // Refs:
+  // - https://groups.google.com/forum/#!topic/nodejs-dev/rxZ_RoH1Gn0
+  // - https://github.com/nodejs/node/issues/21331
+
+  // Test is Linux-specific.
+  if (!common.isLinux)
+    return;
+
+  const fileHandle = await open('/proc/sys/kernel/hostname', 'r');
+  const hostname = await fileHandle.readFile();
+  assert.ok(hostname.length > 0);
+}
+
 validateReadFile()
+  .then(() => validateReadFileProc())
   .then(common.mustCall());
diff --git a/test/parallel/test-fs-promises-readfile.js b/test/parallel/test-fs-promises-readfile.js
index 4334673c30f5fb..b1186ad2172507 100644
--- a/test/parallel/test-fs-promises-readfile.js
+++ b/test/parallel/test-fs-promises-readfile.js
@@ -12,17 +12,35 @@ const fn = path.join(tmpdir.path, 'large-file');
 
 common.crashOnUnhandledRejection();
 
-// Creating large buffer with random content
-const buffer = Buffer.from(
-  Array.apply(null, { length: 16834 * 2 })
-    .map(Math.random)
-    .map((number) => (number * (1 << 8)))
-);
-
-// Writing buffer to a file then try to read it
-writeFile(fn, buffer)
-  .then(() => readFile(fn))
-  .then((readBuffer) => {
-    assert.strictEqual(readBuffer.equals(buffer), true);
-  })
+async function validateReadFile() {
+  // Creating large buffer with random content
+  const buffer = Buffer.from(
+    Array.apply(null, { length: 16834 * 2 })
+      .map(Math.random)
+      .map((number) => (number * (1 << 8)))
+  );
+
+  // Writing buffer to a file then try to read it
+  await writeFile(fn, buffer);
+  const readBuffer = await readFile(fn);
+  assert.strictEqual(readBuffer.equals(buffer), true);
+}
+
+async function validateReadFileProc() {
+  // Test to make sure reading a file under the /proc directory works. Adapted
+  // from test-fs-read-file-sync-hostname.js.
+  // Refs:
+  // - https://groups.google.com/forum/#!topic/nodejs-dev/rxZ_RoH1Gn0
+  // - https://github.com/nodejs/node/issues/21331
+
+  // Test is Linux-specific.
+  if (!common.isLinux)
+    return;
+
+  const hostname = await readFile('/proc/sys/kernel/hostname');
+  assert.ok(hostname.length > 0);
+}
+
+validateReadFile()
+  .then(() => validateReadFileProc())
   .then(common.mustCall());

From 47b10e30c07833d6642ed7216ebbeab036692acd Mon Sep 17 00:00:00 2001
From: Developer Davo <DeveloperDavo@users.noreply.github.com>
Date: Sat, 30 Jun 2018 08:55:23 +0200
Subject: [PATCH 010/116] test: replace third argument with comment in strict
 equals
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21603
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 test/parallel/test-tls-env-bad-extra-ca.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-tls-env-bad-extra-ca.js b/test/parallel/test-tls-env-bad-extra-ca.js
index e141de34a9fe1b..5167f586079187 100644
--- a/test/parallel/test-tls-env-bad-extra-ca.js
+++ b/test/parallel/test-tls-env-bad-extra-ca.js
@@ -29,7 +29,8 @@ let stderr = '';
 
 fork(__filename, opts)
   .on('exit', common.mustCall(function(status) {
-    assert.strictEqual(status, 0, 'client did not succeed in connecting');
+    // Check that client succeeded in connecting.
+    assert.strictEqual(status, 0);
   }))
   .on('close', common.mustCall(function() {
     // TODO(addaleax): Make `SafeGetenv` work like `process.env`

From f3c397cd212dfa372e3a23012a62aae62b36011e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Wed, 13 Jun 2018 15:30:21 +0200
Subject: [PATCH 011/116] console: implement timeLog method

Refs: https://github.com/whatwg/console/pull/138

PR-URL: https://github.com/nodejs/node/pull/21312
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/console.md            | 19 ++++++++++++++++
 lib/console.js                | 28 +++++++++++++++++++-----
 test/parallel/test-console.js | 41 +++++++++++++++++++++++++++--------
 3 files changed, 73 insertions(+), 15 deletions(-)

diff --git a/doc/api/console.md b/doc/api/console.md
index 6c63a4ffb56656..95801c31fed63c 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -413,6 +413,25 @@ console.timeEnd('100-elements');
 // prints 100-elements: 225.438ms
 ```
 
+### console.timeLog([label][, ...data])
+<!-- YAML
+added: REPLACEME
+-->
+* `label` {string} **Default:** `'default'`
+* `...data` {any}
+
+For a timer that was previously started by calling [`console.time()`][], prints
+the elapsed time and other `data` arguments to `stdout`:
+
+```js
+console.time('process');
+const value = expensiveProcess1(); // Returns 42
+console.timeLog('process', value);
+// Prints "process: 365.227ms 42".
+doExpensiveProcess2(value);
+console.timeEnd('process');
+```
+
 ### console.trace([message][, ...args])
 <!-- YAML
 added: v0.1.104
diff --git a/lib/console.js b/lib/console.js
index ed4b6fe9145069..fee3f8ac0b155d 100644
--- a/lib/console.js
+++ b/lib/console.js
@@ -231,18 +231,34 @@ Console.prototype.time = function time(label = 'default') {
 };
 
 Console.prototype.timeEnd = function timeEnd(label = 'default') {
+  const hasWarned = timeLogImpl(this, 'timeEnd', label);
+  if (!hasWarned) {
+    this._times.delete(label);
+  }
+};
+
+Console.prototype.timeLog = function timeLog(label, ...data) {
+  timeLogImpl(this, 'timeLog', label, data);
+};
+
+// Returns true if label was not found
+function timeLogImpl(self, name, label = 'default', data) {
   // Coerces everything other than Symbol to a string
   label = `${label}`;
-  const time = this._times.get(label);
+  const time = self._times.get(label);
   if (!time) {
-    process.emitWarning(`No such label '${label}' for console.timeEnd()`);
-    return;
+    process.emitWarning(`No such label '${label}' for console.${name}()`);
+    return true;
   }
   const duration = process.hrtime(time);
   const ms = duration[0] * 1000 + duration[1] / 1e6;
-  this.log('%s: %sms', label, ms.toFixed(3));
-  this._times.delete(label);
-};
+  if (data === undefined) {
+    self.log('%s: %sms', label, ms.toFixed(3));
+  } else {
+    self.log('%s: %sms', label, ms.toFixed(3), ...data);
+  }
+  return false;
+}
 
 Console.prototype.trace = function trace(...args) {
   const err = {
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index 1b44ca9c4dac65..b8dfac2f29888a 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -22,6 +22,7 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+const util = require('util');
 
 assert.ok(process.stdout.writable);
 assert.ok(process.stderr.writable);
@@ -30,11 +31,17 @@ if (common.isMainThread) {
   assert.strictEqual(typeof process.stdout.fd, 'number');
   assert.strictEqual(typeof process.stderr.fd, 'number');
 }
-process.once('warning', common.mustCall((warning) => {
-  assert(/no such label/.test(warning.message));
-}));
 
-console.timeEnd('no such label');
+common.expectWarning(
+  'Warning',
+  [
+    ['No such label \'nolabel\' for console.timeEnd()', common.noWarnCode],
+    ['No such label \'nolabel\' for console.timeLog()', common.noWarnCode]
+  ]
+);
+
+console.timeEnd('nolabel');
+console.timeLog('nolabel');
 
 console.time('label');
 console.timeEnd('label');
@@ -47,8 +54,8 @@ assert.throws(() => console.timeEnd(Symbol('test')),
               TypeError);
 
 
-// an Object with a custom .inspect() function
-const custom_inspect = { foo: 'bar', inspect: () => 'inspect' };
+// An Object with a custom inspect function.
+const custom_inspect = { foo: 'bar', [util.inspect.custom]: () => 'inspect' };
 
 const strings = [];
 const errStrings = [];
@@ -139,6 +146,12 @@ console.timeEnd();
 console.time(NaN);
 console.timeEnd(NaN);
 
+console.time('log1');
+console.timeLog('log1');
+console.timeLog('log1', 'test');
+console.timeLog('log1', {}, [1, 2, 3]);
+console.timeEnd('log1');
+
 console.assert(false, '%s should', 'console.assert', 'not throw');
 assert.strictEqual(errStrings[errStrings.length - 1],
                    'Assertion failed: console.assert should not throw\n');
@@ -179,9 +192,11 @@ for (const expected of expectedStrings) {
 }
 
 assert.strictEqual(strings.shift(),
-                   "{ foo: 'bar', inspect: [Function: inspect] }\n");
+                   "{ foo: 'bar',\n  [Symbol(util.inspect.custom)]: " +
+                    '[Function: [util.inspect.custom]] }\n');
 assert.strictEqual(strings.shift(),
-                   "{ foo: 'bar', inspect: [Function: inspect] }\n");
+                   "{ foo: 'bar',\n  [Symbol(util.inspect.custom)]: " +
+                    '[Function: [util.inspect.custom]] }\n');
 assert.ok(strings.shift().includes('foo: [Object]'));
 assert.strictEqual(strings.shift().includes('baz'), false);
 assert.strictEqual(strings.shift(), 'inspect inspect\n');
@@ -202,6 +217,14 @@ assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^NaN: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 
+assert.ok(/^log1: \d+\.\d{3}ms$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+\.\d{3}ms test$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+\.\d{3}ms {} \[ 1, 2, 3 ]$/.test(strings.shift().trim()));
+assert.ok(/^log1: \d+\.\d{3}ms$/.test(strings.shift().trim()));
+
+// Make sure that we checked all strings
+assert.strictEqual(strings.length, 0);
+
 assert.strictEqual(errStrings.shift().split('\n').shift(),
                    'Trace: This is a {"formatted":"trace"} 10 foo');
 
@@ -212,6 +235,6 @@ common.hijackStderr(common.mustCall(function(data) {
 
   // stderr.write will catch sync error, so use `process.nextTick` here
   process.nextTick(function() {
-    assert.strictEqual(data.includes('no such label'), true);
+    assert.strictEqual(data.includes('nolabel'), true);
   });
 }));

From ceec23e6e48c535f5e3ccd09701f80a34c5ea9c2 Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Tue, 3 Jul 2018 12:28:25 +0200
Subject: [PATCH 012/116] src: remove using directives from spawn_sync.h

I noticed that there were a few using declarations what were unused and
instead of just removing them, this commit removes all of them and uses
qualified names instead since they are in a header.

PR-URL: https://github.com/nodejs/node/pull/21634
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/spawn_sync.h | 42 +++++++++++++++---------------------------
 1 file changed, 15 insertions(+), 27 deletions(-)

diff --git a/src/spawn_sync.h b/src/spawn_sync.h
index 806431846691db..fed14532960326 100644
--- a/src/spawn_sync.h
+++ b/src/spawn_sync.h
@@ -29,18 +29,6 @@
 
 namespace node {
 
-using v8::Array;
-using v8::Context;
-using v8::FunctionCallbackInfo;
-using v8::HandleScope;
-using v8::Integer;
-using v8::Isolate;
-using v8::Local;
-using v8::Null;
-using v8::Number;
-using v8::Object;
-using v8::String;
-using v8::Value;
 
 
 class SyncProcessOutputBuffer;
@@ -94,7 +82,7 @@ class SyncProcessStdioPipe {
   int Start();
   void Close();
 
-  Local<Object> GetOutputAsBuffer(Environment* env) const;
+  v8::Local<v8::Object> GetOutputAsBuffer(Environment* env) const;
 
   inline bool readable() const;
   inline bool writable() const;
@@ -151,10 +139,10 @@ class SyncProcessRunner {
   };
 
  public:
-  static void Initialize(Local<Object> target,
-                         Local<Value> unused,
-                         Local<Context> context);
-  static void Spawn(const FunctionCallbackInfo<Value>& args);
+  static void Initialize(v8::Local<v8::Object> target,
+                         v8::Local<v8::Value> unused,
+                         v8::Local<v8::Context> context);
+  static void Spawn(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  private:
   friend class SyncProcessStdioPipe;
@@ -164,8 +152,8 @@ class SyncProcessRunner {
 
   inline Environment* env() const;
 
-  Local<Object> Run(Local<Value> options);
-  void TryInitializeAndRunLoop(Local<Value> options);
+  v8::Local<v8::Object> Run(v8::Local<v8::Value> options);
+  void TryInitializeAndRunLoop(v8::Local<v8::Value> options);
   void CloseHandlesAndDeleteLoop();
 
   void CloseStdioPipes();
@@ -181,12 +169,12 @@ class SyncProcessRunner {
   void SetError(int error);
   void SetPipeError(int pipe_error);
 
-  Local<Object> BuildResultObject();
-  Local<Array> BuildOutputArray();
+  v8::Local<v8::Object> BuildResultObject();
+  v8::Local<v8::Array> BuildOutputArray();
 
-  int ParseOptions(Local<Value> js_value);
-  int ParseStdioOptions(Local<Value> js_value);
-  int ParseStdioOption(int child_fd, Local<Object> js_stdio_option);
+  int ParseOptions(v8::Local<v8::Value> js_value);
+  int ParseStdioOptions(v8::Local<v8::Value> js_value);
+  int ParseStdioOption(int child_fd, v8::Local<v8::Object> js_stdio_option);
 
   inline int AddStdioIgnore(uint32_t child_fd);
   inline int AddStdioPipe(uint32_t child_fd,
@@ -195,9 +183,9 @@ class SyncProcessRunner {
                           uv_buf_t input_buffer);
   inline int AddStdioInheritFD(uint32_t child_fd, int inherit_fd);
 
-  static bool IsSet(Local<Value> value);
-  int CopyJsString(Local<Value> js_value, const char** target);
-  int CopyJsStringArray(Local<Value> js_value, char** target);
+  static bool IsSet(v8::Local<v8::Value> value);
+  int CopyJsString(v8::Local<v8::Value> js_value, const char** target);
+  int CopyJsStringArray(v8::Local<v8::Value> js_value, char** target);
 
   static void ExitCallback(uv_process_t* handle,
                            int64_t exit_status,

From c88af232c847445dfb60c9dda3e46f512084fe3e Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <deb2001-github@yahoo.de>
Date: Fri, 15 Jun 2018 23:37:46 +0200
Subject: [PATCH 013/116] http2: pass incoming set-cookie header as array

Incoming set-cookie headers should be passed to user as array like in
http module.

Besides improving compatibility between http and http2 it avoids the
need to check if the type is an array or not in user code.

PR-URL: https://github.com/nodejs/node/pull/21360
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/http2.md                              |  3 +-
 lib/internal/http2/util.js                    |  7 +--
 test/parallel/test-http2-util-headers-list.js | 44 +++++++++++++++++--
 3 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/doc/api/http2.md b/doc/api/http2.md
index b320e1d632354b..3e1850a6790b94 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -2130,8 +2130,7 @@ For incoming headers:
 `proxy-authorization`, `range`, `referer`,`retry-after`, `tk`,
 `upgrade-insecure-requests`, `user-agent` or `x-content-type-options` are
 discarded.
-* `set-cookie` is a string if present once or an array in case duplicates
-are present.
+* `set-cookie` is always an array. Duplicates are added to the array.
 * `cookie`: the values are joined together with '; '.
 * For all other headers, the values are joined together with ', '.
 
diff --git a/lib/internal/http2/util.js b/lib/internal/http2/util.js
index bf5d07219391e2..bc93662a70239d 100644
--- a/lib/internal/http2/util.js
+++ b/lib/internal/http2/util.js
@@ -509,7 +509,7 @@ function toHeaderObject(headers) {
       value |= 0;
     var existing = obj[name];
     if (existing === undefined) {
-      obj[name] = value;
+      obj[name] = name === HTTP2_HEADER_SET_COOKIE ? [value] : value;
     } else if (!kSingleValueHeaders.has(name)) {
       switch (name) {
         case HTTP2_HEADER_COOKIE:
@@ -528,10 +528,7 @@ function toHeaderObject(headers) {
           // fields with the same name.  Since it cannot be combined into a
           // single field-value, recipients ought to handle "Set-Cookie" as a
           // special case while processing header fields."
-          if (Array.isArray(existing))
-            existing.push(value);
-          else
-            obj[name] = [existing, value];
+          existing.push(value);
           break;
         default:
           // https://tools.ietf.org/html/rfc7230#section-3.2.2
diff --git a/test/parallel/test-http2-util-headers-list.js b/test/parallel/test-http2-util-headers-list.js
index 772e9c8679feef..7b838835531977 100644
--- a/test/parallel/test-http2-util-headers-list.js
+++ b/test/parallel/test-http2-util-headers-list.js
@@ -1,14 +1,14 @@
 // Flags: --expose-internals
 'use strict';
 
-// Tests the internal utility function that is used to prepare headers
-// to pass to the internal binding layer.
+// Tests the internal utility functions that are used to prepare headers
+// to pass to the internal binding layer and to build a header object.
 
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 const assert = require('assert');
-const { mapToHeaders } = require('internal/http2/util');
+const { mapToHeaders, toHeaderObject } = require('internal/http2/util');
 
 const {
   HTTP2_HEADER_STATUS,
@@ -305,3 +305,41 @@ common.expectsError({
 
 assert(!(mapToHeaders({ te: 'trailers' }) instanceof Error));
 assert(!(mapToHeaders({ te: ['trailers'] }) instanceof Error));
+
+
+{
+  const rawHeaders = [
+    ':status', '200',
+    'cookie', 'foo',
+    'set-cookie', 'sc1',
+    'age', '10',
+    'x-multi', 'first'
+  ];
+  const headers = toHeaderObject(rawHeaders);
+  assert.strictEqual(headers[':status'], 200);
+  assert.strictEqual(headers.cookie, 'foo');
+  assert.deepStrictEqual(headers['set-cookie'], ['sc1']);
+  assert.strictEqual(headers.age, '10');
+  assert.strictEqual(headers['x-multi'], 'first');
+}
+
+{
+  const rawHeaders = [
+    ':status', '200',
+    ':status', '400',
+    'cookie', 'foo',
+    'cookie', 'bar',
+    'set-cookie', 'sc1',
+    'set-cookie', 'sc2',
+    'age', '10',
+    'age', '20',
+    'x-multi', 'first',
+    'x-multi', 'second'
+  ];
+  const headers = toHeaderObject(rawHeaders);
+  assert.strictEqual(headers[':status'], 200);
+  assert.strictEqual(headers.cookie, 'foo; bar');
+  assert.deepStrictEqual(headers['set-cookie'], ['sc1', 'sc2']);
+  assert.strictEqual(headers.age, '10');
+  assert.strictEqual(headers['x-multi'], 'first, second');
+}

From 021dd5404ce6d83636d50c6dfad0364df07a5611 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jacek=20Pospycha=C5=82a?=
 <jacek.pospychala@currency-one.com>
Date: Tue, 3 Jul 2018 19:02:59 +0200
Subject: [PATCH 014/116] test: remove unnecessary string literals

PR-URL: https://github.com/nodejs/node/pull/21638
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/parallel/test-vm-function-declaration.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/parallel/test-vm-function-declaration.js b/test/parallel/test-vm-function-declaration.js
index 0f6f19b13ebcf1..6405babfa78148 100644
--- a/test/parallel/test-vm-function-declaration.js
+++ b/test/parallel/test-vm-function-declaration.js
@@ -37,8 +37,8 @@ code += '(function(){return this})().b;\n';
 
 const res = vm.runInContext(code, o, 'test');
 
-assert.strictEqual(typeof res, 'function', 'result should be function');
-assert.strictEqual(res.name, 'b', 'res should be named b');
-assert.strictEqual(typeof o.a, 'function', 'a should be function');
-assert.strictEqual(typeof o.b, 'function', 'b should be function');
-assert.strictEqual(res, o.b, 'result should be global b function');
+assert.strictEqual(typeof res, 'function');
+assert.strictEqual(res.name, 'b');
+assert.strictEqual(typeof o.a, 'function');
+assert.strictEqual(typeof o.b, 'function');
+assert.strictEqual(res, o.b);

From cec166e85f32e02fc0789943cabf94abad415c92 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Thu, 7 Dec 2017 15:01:13 -0800
Subject: [PATCH 015/116] n-api: restrict exports by version

* Move `napi_get_uv_event_loop` into the `NAPI_VERSION >= 2` section
* Move `napi_open_callback_scope`, `napi_close_callback_scope`,
  `napi_fatal_exception`, `napi_add_env_cleanup_hook`, and
  `napi_remove_env_cleanup_hook` into the `NAPI_VERSION >= 3` section
* Added a missing `added` property to `napi_get_uv_event_loop` in the
  docs
* Added a `napiVersion` property to the docs and updated the parser and
  generator to use it.
* Added usage documentation

PR-URL: https://github.com/nodejs/node/pull/19962
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md    | 162 +++++++++++++++++++++++++++++++++++++++++++-
 src/node_api.h      |  55 ++++++++++-----
 tools/doc/common.js |   4 ++
 tools/doc/html.js   |   4 ++
 4 files changed, 207 insertions(+), 18 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 0d3fdc3a078167..982b15f496893b 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -42,6 +42,8 @@ for the N-API C based functions exported by Node.js. These wrappers are not
 part of N-API, nor will they be maintained as part of Node.js. One such
 example is: [node-addon-api](https://github.com/nodejs/node-addon-api).
 
+## Usage
+
 In order to use the N-API functions, include the file
 [`node_api.h`](https://github.com/nodejs/node/blob/master/src/node_api.h)
 which is located in the src directory in the node development tree:
@@ -50,6 +52,41 @@ which is located in the src directory in the node development tree:
 #include <node_api.h>
 ```
 
+This will opt into the default `NAPI_VERSION` for the given release of Node.js.
+In order to ensure compatibility with specific versions of N-API, the version
+can be specified explicitly when including the header:
+
+```C
+#define NAPI_VERSION 3
+#include <node_api.h>
+```
+
+This restricts the N-API surface to just the functionality that was available in
+the specified (and earlier) versions.
+
+Some of the N-API surface is considered experimental and requires explicit
+opt-in to access those APIs:
+
+```C
+#define NAPI_EXPERIMENTAL
+#include <node_api.h>
+```
+
+In this case the entire API surface, including any experimental APIs, will be
+available to the module code.
+
+## N-API Version Matrix
+
+|       | 1       | 2        | 3        |
+|:-----:|:-------:|:--------:|:--------:|
+| v4.x  |         |          |          |
+| v6.x  |         |          | v6.14.2* |
+| v8.x  | v8.0.0* | v8.10.0* |          |
+| v9.x  | v9.0.0* | v9.3.0*  | v9.11.0* |
+| v10.x |         |          | v10.0.0  |
+
+\* Indicates that the N-API version was released as experimental
+
 ## Basic N-API Data Types
 
 N-API exposes the following fundamental datatypes as abstractions that are
@@ -326,6 +363,7 @@ logging purposes.
 #### napi_get_last_error_info
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status
@@ -424,6 +462,7 @@ TypeError [ERR_ERROR_1]
 #### napi_throw
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error);
@@ -438,6 +477,7 @@ This API throws the JavaScript value provided.
 #### napi_throw_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_throw_error(napi_env env,
@@ -456,6 +496,7 @@ This API throws a JavaScript `Error` with the text provided.
 #### napi_throw_type_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_throw_type_error(napi_env env,
@@ -474,6 +515,7 @@ This API throws a JavaScript `TypeError` with the text provided.
 #### napi_throw_range_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_throw_range_error(napi_env env,
@@ -492,6 +534,7 @@ This API throws a JavaScript `RangeError` with the text provided.
 #### napi_is_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_is_error(napi_env env,
@@ -510,6 +553,7 @@ This API queries a `napi_value` to check if it represents an error object.
 #### napi_create_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_create_error(napi_env env,
@@ -531,6 +575,7 @@ This API returns a JavaScript `Error` with the text provided.
 #### napi_create_type_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_create_type_error(napi_env env,
@@ -552,6 +597,7 @@ This API returns a JavaScript `TypeError` with the text provided.
 #### napi_create_range_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_create_range_error(napi_env env,
@@ -573,6 +619,7 @@ This API returns a JavaScript `RangeError` with the text provided.
 #### napi_get_and_clear_last_exception
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_and_clear_last_exception(napi_env env,
@@ -591,6 +638,7 @@ This API can be called even if there is a pending JavaScript exception.
 #### napi_is_exception_pending
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_exception_pending(napi_env env, bool* result);
@@ -608,7 +656,9 @@ This API can be called even if there is a pending JavaScript exception.
 #### napi_fatal_exception
 <!-- YAML
 added: v9.10.0
+napiVersion: 3
 -->
+
 ```C
 napi_status napi_fatal_exception(napi_env env, napi_value err);
 ```
@@ -627,6 +677,7 @@ thrown to immediately terminate the process.
 #### napi_fatal_error
 <!-- YAML
 added: v8.2.0
+napiVersion: 1
 -->
 ```C
 NAPI_NO_RETURN void napi_fatal_error(const char* location,
@@ -740,6 +791,7 @@ can only be called once.
 #### napi_open_handle_scope
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_open_handle_scope(napi_env env,
@@ -755,6 +807,7 @@ This API open a new scope.
 #### napi_close_handle_scope
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_close_handle_scope(napi_env env,
@@ -773,6 +826,7 @@ This API can be called even if there is a pending JavaScript exception.
 #### napi_open_escapable_handle_scope
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status
@@ -790,6 +844,7 @@ to the outer scope.
 #### napi_close_escapable_handle_scope
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status
@@ -809,6 +864,7 @@ This API can be called even if there is a pending JavaScript exception.
 #### napi_escape_handle
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_escape_handle(napi_env env,
@@ -874,6 +930,7 @@ individual count.
 #### napi_create_reference
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_create_reference(napi_env env,
@@ -896,6 +953,7 @@ to the `Object` passed in.
 #### napi_delete_reference
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_delete_reference(napi_env env, napi_ref ref);
@@ -913,6 +971,7 @@ This API can be called even if there is a pending JavaScript exception.
 #### napi_reference_ref
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_reference_ref(napi_env env,
@@ -931,6 +990,7 @@ passed in and returns the resulting reference count.
 #### napi_reference_unref
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_reference_unref(napi_env env,
@@ -949,6 +1009,7 @@ passed in and returns the resulting reference count.
 #### napi_get_reference_value
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_get_reference_value(napi_env env,
@@ -982,7 +1043,9 @@ should be freed up.
 #### napi_add_env_cleanup_hook
 <!-- YAML
 added: v10.2.0
+napiVersion: 3
 -->
+
 ```C
 NODE_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env,
                                                   void (*fun)(void* arg),
@@ -1007,7 +1070,9 @@ is being torn down anyway.
 #### napi_remove_env_cleanup_hook
 <!-- YAML
 added: v10.2.0
+napiVersion: 3
 -->
+
 ```C
 NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env,
                                                      void (*fun)(void* arg),
@@ -1196,6 +1261,7 @@ Elements of this enum correspond to
 #### napi_create_array
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_array(napi_env env, napi_value* result)
@@ -1213,6 +1279,7 @@ JavaScript arrays are described in
 #### napi_create_array_with_length
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_array_with_length(napi_env env,
@@ -1241,6 +1308,7 @@ JavaScript arrays are described in
 #### napi_create_arraybuffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_arraybuffer(napi_env env,
@@ -1272,6 +1340,7 @@ JavaScript `ArrayBuffer` objects are described in
 #### napi_create_buffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_buffer(napi_env env,
@@ -1293,6 +1362,7 @@ fully-supported data structure, in most cases using a `TypedArray` will suffice.
 #### napi_create_buffer_copy
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_buffer_copy(napi_env env,
@@ -1318,6 +1388,7 @@ structure, in most cases using a `TypedArray` will suffice.
 #### napi_create_external
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_external(napi_env env,
@@ -1350,6 +1421,7 @@ an external value yields `napi_external`.
 #### napi_create_external_arraybuffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status
@@ -1384,6 +1456,7 @@ JavaScript `ArrayBuffer`s are described in
 #### napi_create_external_buffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_external_buffer(napi_env env,
@@ -1415,6 +1488,7 @@ For Node.js >=4 `Buffers` are `Uint8Array`s.
 #### napi_create_function
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_function(napi_env env,
@@ -1448,6 +1522,7 @@ of the ECMAScript Language Specification.
 #### napi_create_object
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_object(napi_env env, napi_value* result)
@@ -1468,6 +1543,7 @@ ECMAScript Language Specification.
 #### napi_create_symbol
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_symbol(napi_env env,
@@ -1491,6 +1567,7 @@ of the ECMAScript Language Specification.
 #### napi_create_typedarray
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_typedarray(napi_env env,
@@ -1526,6 +1603,7 @@ JavaScript `TypedArray` objects are described in
 #### napi_create_dataview
 <!-- YAML
 added: v8.3.0
+napiVersion: 1
 -->
 
 ```C
@@ -1560,6 +1638,7 @@ JavaScript `DataView` objects are described in
 #### napi_create_int32
 <!-- YAML
 added: v8.4.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)
@@ -1580,6 +1659,7 @@ The JavaScript `Number` type is described in
 #### napi_create_uint32
 <!-- YAML
 added: v8.4.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)
@@ -1600,6 +1680,7 @@ The JavaScript `Number` type is described in
 #### napi_create_int64
 <!-- YAML
 added: v8.4.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)
@@ -1626,6 +1707,7 @@ outside the range of
 #### napi_create_double
 <!-- YAML
 added: v8.4.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_double(napi_env env, double value, napi_value* result)
@@ -1646,6 +1728,7 @@ The JavaScript `Number` type is described in
 #### napi_create_string_latin1
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_string_latin1(napi_env env,
@@ -1671,6 +1754,7 @@ The JavaScript `String` type is described in
 #### napi_create_string_utf16
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_string_utf16(napi_env env,
@@ -1696,6 +1780,7 @@ The JavaScript `String` type is described in
 #### napi_create_string_utf8
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_string_utf8(napi_env env,
@@ -1722,6 +1807,7 @@ The JavaScript `String` type is described in
 #### napi_get_array_length
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_array_length(napi_env env,
@@ -1745,6 +1831,7 @@ of the ECMAScript Language Specification.
 #### napi_get_arraybuffer_info
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_arraybuffer_info(napi_env env,
@@ -1774,6 +1861,7 @@ trigger a GC.
 #### napi_get_buffer_info
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_buffer_info(napi_env env,
@@ -1798,6 +1886,7 @@ lifetime is not guaranteed if it's managed by the VM.
 #### napi_get_prototype
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_prototype(napi_env env,
@@ -1816,6 +1905,7 @@ Returns `napi_ok` if the API succeeded.
 #### napi_get_typedarray_info
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_typedarray_info(napi_env env,
@@ -1852,6 +1942,7 @@ is managed by the VM.
 #### napi_get_dataview_info
 <!-- YAML
 added: v8.3.0
+napiVersion: 1
 -->
 
 ```C
@@ -1879,6 +1970,7 @@ This API returns various properties of a `DataView`.
 #### napi_get_value_bool
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result)
@@ -1898,6 +1990,7 @@ This API returns the C boolean primitive equivalent of the given JavaScript
 #### napi_get_value_double
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_double(napi_env env,
@@ -1919,6 +2012,7 @@ This API returns the C double primitive equivalent of the given JavaScript
 #### napi_get_value_external
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_external(napi_env env,
@@ -1939,6 +2033,7 @@ This API retrieves the external data pointer that was previously passed to
 #### napi_get_value_int32
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_int32(napi_env env,
@@ -1967,6 +2062,7 @@ result to zero.
 #### napi_get_value_int64
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_int64(napi_env env,
@@ -1997,6 +2093,7 @@ result to zero.
 #### napi_get_value_string_latin1
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_string_latin1(napi_env env,
@@ -2024,6 +2121,7 @@ in.
 #### napi_get_value_string_utf8
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_string_utf8(napi_env env,
@@ -2050,6 +2148,7 @@ This API returns the UTF8-encoded string corresponding the value passed in.
 #### napi_get_value_string_utf16
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_string_utf16(napi_env env,
@@ -2076,6 +2175,7 @@ This API returns the UTF16-encoded string corresponding the value passed in.
 #### napi_get_value_uint32
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_value_uint32(napi_env env,
@@ -2098,6 +2198,7 @@ This API returns the C primitive equivalent of the given `napi_value` as a
 #### napi_get_boolean
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_boolean(napi_env env, bool value, napi_value* result)
@@ -2116,6 +2217,7 @@ represent the given boolean value.
 #### napi_get_global
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_global(napi_env env, napi_value* result)
@@ -2131,6 +2233,7 @@ This API returns the `global` object.
 #### napi_get_null
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_null(napi_env env, napi_value* result)
@@ -2146,6 +2249,7 @@ This API returns the `null` object.
 #### napi_get_undefined
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_undefined(napi_env env, napi_value* result)
@@ -2174,6 +2278,7 @@ These APIs support doing one of the following:
 ### napi_coerce_to_bool
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_coerce_to_bool(napi_env env,
@@ -2195,6 +2300,7 @@ This API can be re-entrant if getters are defined on the passed-in `Object`.
 ### napi_coerce_to_number
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_coerce_to_number(napi_env env,
@@ -2216,6 +2322,7 @@ This API can be re-entrant if getters are defined on the passed-in `Object`.
 ### napi_coerce_to_object
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_coerce_to_object(napi_env env,
@@ -2237,6 +2344,7 @@ This API can be re-entrant if getters are defined on the passed-in `Object`.
 ### napi_coerce_to_string
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_coerce_to_string(napi_env env,
@@ -2258,6 +2366,7 @@ This API can be re-entrant if getters are defined on the passed-in `Object`.
 ### napi_typeof
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result)
@@ -2279,6 +2388,7 @@ If `value` has a type that is invalid, an error is returned.
 ### napi_instanceof
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_instanceof(napi_env env,
@@ -2304,6 +2414,7 @@ of the ECMAScript Language Specification.
 ### napi_is_array
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_array(napi_env env, napi_value value, bool* result)
@@ -2322,6 +2433,7 @@ of the ECMAScript Language Specification.
 ### napi_is_arraybuffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result)
@@ -2338,6 +2450,7 @@ This API checks if the `Object` passed in is an array buffer.
 ### napi_is_buffer
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_buffer(napi_env env, napi_value value, bool* result)
@@ -2355,6 +2468,7 @@ This API checks if the `Object` passed in is a buffer.
 ### napi_is_error
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_error(napi_env env, napi_value value, bool* result)
@@ -2371,6 +2485,7 @@ This API checks if the `Object` passed in is an `Error`.
 ### napi_is_typedarray
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result)
@@ -2387,6 +2502,7 @@ This API checks if the `Object` passed in is a typed array.
 ### napi_is_dataview
 <!-- YAML
 added: v8.3.0
+napiVersion: 1
 -->
 
 ```C
@@ -2404,6 +2520,7 @@ This API checks if the `Object` passed in is a `DataView`.
 ### napi_strict_equals
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_strict_equals(napi_env env,
@@ -2636,6 +2753,7 @@ this function is invoked.
 #### napi_get_property_names
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_property_names(napi_env env,
@@ -2659,6 +2777,7 @@ included.
 #### napi_set_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_set_property(napi_env env,
@@ -2679,6 +2798,7 @@ This API set a property on the `Object` passed in.
 #### napi_get_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_property(napi_env env,
@@ -2699,6 +2819,7 @@ This API gets the requested property from the `Object` passed in.
 #### napi_has_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_has_property(napi_env env,
@@ -2719,6 +2840,7 @@ This API checks if the `Object` passed in has the named property.
 #### napi_delete_property
 <!-- YAML
 added: v8.2.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_delete_property(napi_env env,
@@ -2740,6 +2862,7 @@ This API attempts to delete the `key` own property from `object`.
 #### napi_has_own_property
 <!-- YAML
 added: v8.2.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_has_own_property(napi_env env,
@@ -2762,6 +2885,7 @@ any conversion between data types.
 #### napi_set_named_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_set_named_property(napi_env env,
@@ -2783,6 +2907,7 @@ created from the string passed in as `utf8Name`.
 #### napi_get_named_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_named_property(napi_env env,
@@ -2804,6 +2929,7 @@ created from the string passed in as `utf8Name`.
 #### napi_has_named_property
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_has_named_property(napi_env env,
@@ -2825,6 +2951,7 @@ created from the string passed in as `utf8Name`.
 #### napi_set_element
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_set_element(napi_env env,
@@ -2845,6 +2972,7 @@ This API sets and element on the `Object` passed in.
 #### napi_get_element
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_element(napi_env env,
@@ -2865,6 +2993,7 @@ This API gets the element at the requested index.
 #### napi_has_element
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_has_element(napi_env env,
@@ -2886,6 +3015,7 @@ requested index.
 #### napi_delete_element
 <!-- YAML
 added: v8.2.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_delete_element(napi_env env,
@@ -2907,6 +3037,7 @@ This API attempts to delete the specified `index` from `object`.
 #### napi_define_properties
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_define_properties(napi_env env,
@@ -2950,6 +3081,7 @@ function.
 ### napi_call_function
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_call_function(napi_env env,
@@ -3016,6 +3148,7 @@ if (status != napi_ok) return;
 ### napi_create_function
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_function(napi_env env,
@@ -3083,6 +3216,7 @@ responsible for creating the `.node` file.
 ### napi_get_cb_info
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_cb_info(napi_env env,
@@ -3113,6 +3247,7 @@ call like the arguments and the `this` pointer from a given callback info.
 ### napi_get_new_target
 <!-- YAML
 added: v8.6.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_new_target(napi_env env,
@@ -3132,6 +3267,7 @@ callback is not a constructor call, the result is `NULL`.
 ### napi_new_instance
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_new_instance(napi_env env,
@@ -3227,6 +3363,7 @@ The reference must be freed once it is no longer needed.
 ### napi_define_class
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_define_class(napi_env env,
@@ -3283,6 +3420,7 @@ reference count is kept >= 1.
 ### napi_wrap
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_wrap(napi_env env,
@@ -3343,6 +3481,7 @@ first.
 ### napi_unwrap
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_unwrap(napi_env env,
@@ -3368,6 +3507,7 @@ then by calling `napi_unwrap()` on the wrapper object.
 ### napi_remove_wrap
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_remove_wrap(napi_env env,
@@ -3444,6 +3584,7 @@ callback invocation, even when it was cancelled.
 ### napi_create_async_work
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 changes:
   - version: v8.6.0
     pr-url: https://github.com/nodejs/node/pull/14697
@@ -3491,6 +3632,7 @@ the [`async_hooks` documentation][async_hooks `type`] for more information.
 ### napi_delete_async_work
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_delete_async_work(napi_env env,
@@ -3509,6 +3651,7 @@ This API can be called even if there is a pending JavaScript exception.
 ### napi_queue_async_work
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_queue_async_work(napi_env env,
@@ -3526,6 +3669,7 @@ for execution.
 ### napi_cancel_async_work
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_cancel_async_work(napi_env env,
@@ -3555,6 +3699,7 @@ the runtime.
 ### napi_async_init
 <!-- YAML
 added: v8.6.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_async_init(napi_env env,
@@ -3576,6 +3721,7 @@ Returns `napi_ok` if the API succeeded.
 ### napi_async_destroy
 <!-- YAML
 added: v8.6.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_async_destroy(napi_env env,
@@ -3592,6 +3738,7 @@ This API can be called even if there is a pending JavaScript exception.
 ### napi_make_callback
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 changes:
   - version: v8.6.0
     description: Added `async_context` parameter.
@@ -3638,6 +3785,7 @@ may be required when implementing custom async behavior that does not use
 ### napi_open_callback_scope
 <!-- YAML
 added: v9.6.0
+napiVersion: 3
 -->
 ```C
 NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
@@ -3663,6 +3811,7 @@ the required scope.
 ### napi_close_callback_scope
 <!-- YAML
 added: v9.6.0
+napiVersion: 3
 -->
 ```C
 NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
@@ -3678,6 +3827,7 @@ This API can be called even if there is a pending JavaScript exception.
 ### napi_get_node_version
 <!-- YAML
 added: v8.4.0
+napiVersion: 1
 -->
 
 ```C
@@ -3706,6 +3856,7 @@ The returned buffer is statically allocated and does not need to be freed.
 ### napi_get_version
 <!-- YAML
 added: v8.0.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_get_version(napi_env env,
@@ -3736,6 +3887,7 @@ support it:
 ### napi_adjust_external_memory
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_adjust_external_memory(napi_env env,
@@ -3815,6 +3967,7 @@ deferred = NULL;
 ### napi_create_promise
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_create_promise(napi_env env,
@@ -3835,6 +3988,7 @@ This API creates a deferred object and a JavaScript promise.
 ### napi_resolve_deferred
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_resolve_deferred(napi_env env,
@@ -3858,6 +4012,7 @@ The deferred object is freed upon successful completion.
 ### napi_reject_deferred
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_reject_deferred(napi_env env,
@@ -3881,6 +4036,7 @@ The deferred object is freed upon successful completion.
 ### napi_is_promise
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 napi_status napi_is_promise(napi_env env,
@@ -3901,6 +4057,7 @@ underlying JavaScript engine.
 ### napi_run_script
 <!-- YAML
 added: v8.5.0
+napiVersion: 1
 -->
 ```C
 NAPI_EXTERN napi_status napi_run_script(napi_env env,
@@ -3919,7 +4076,10 @@ a specific `napi_env`.
 
 ### napi_get_uv_event_loop
 <!-- YAML
-added: v9.3.0
+added:
+  - v8.10.0
+  - v9.3.0
+napiVersion: 2
 -->
 ```C
 NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
diff --git a/src/node_api.h b/src/node_api.h
index 84706ac3ed6769..b22592db15f110 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -7,6 +7,16 @@
 
 struct uv_loop_s;  // Forward declaration.
 
+#ifndef NAPI_VERSION
+#ifdef NAPI_EXPERIMENTAL
+// Use INT_MAX, this should only be consumed by the pre-processor anyway.
+#define NAPI_VERSION 2147483647
+#else
+// The baseline version for N-API
+#define NAPI_VERSION 3
+#endif
+#endif
+
 #ifdef _WIN32
   #ifdef BUILDING_NODE_EXTENSION
     #ifdef EXTERNAL_NAPI
@@ -118,19 +128,10 @@ EXTERN_C_START
 
 NAPI_EXTERN void napi_module_register(napi_module* mod);
 
-NAPI_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env,
-                                                  void (*fun)(void* arg),
-                                                  void* arg);
-NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env,
-                                                     void (*fun)(void* arg),
-                                                     void* arg);
-
 NAPI_EXTERN napi_status
 napi_get_last_error_info(napi_env env,
                          const napi_extended_error_info** result);
 
-NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err);
-
 NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location,
                                                  size_t location_len,
                                                  const char* message,
@@ -443,14 +444,6 @@ NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
                                            napi_value escapee,
                                            napi_value* result);
 
-NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
-                                                 napi_value resource_object,
-                                                 napi_async_context context,
-                                                 napi_callback_scope* result);
-
-NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
-                                                  napi_callback_scope scope);
-
 // Methods to support error handling
 NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error);
 NAPI_EXTERN napi_status napi_throw_error(napi_env env,
@@ -610,11 +603,38 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
                                         napi_value script,
                                         napi_value* result);
 
+#if NAPI_VERSION >= 2
+
 // Return the current libuv event loop for a given environment
 NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
                                                struct uv_loop_s** loop);
 
+#endif  // NAPI_VERSION >= 2
+
+#if NAPI_VERSION >= 3
+
+NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
+                                                 napi_value resource_object,
+                                                 napi_async_context context,
+                                                 napi_callback_scope* result);
+
+NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
+                                                  napi_callback_scope scope);
+
+NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err);
+
+NAPI_EXTERN napi_status napi_add_env_cleanup_hook(napi_env env,
+                                                  void (*fun)(void* arg),
+                                                  void* arg);
+
+NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(napi_env env,
+                                                     void (*fun)(void* arg),
+                                                     void* arg);
+
+#endif  // NAPI_VERSION >= 3
+
 #ifdef NAPI_EXPERIMENTAL
+
 // Calling into JS from other threads
 NAPI_EXTERN napi_status
 napi_create_threadsafe_function(napi_env env,
@@ -652,6 +672,7 @@ NAPI_EXTERN napi_status
 napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func);
 
 #endif  // NAPI_EXPERIMENTAL
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/tools/doc/common.js b/tools/doc/common.js
index 813935f23b84f4..4dfadd353d9ec8 100644
--- a/tools/doc/common.js
+++ b/tools/doc/common.js
@@ -25,6 +25,10 @@ function extractAndParseYAML(text) {
     meta.added = arrify(meta.added);
   }
 
+  if (meta.napiVersion) {
+    meta.napiVersion = arrify(meta.napiVersion);
+  }
+
   if (meta.deprecated) {
     // Treat deprecated like added for consistency.
     meta.deprecated = arrify(meta.deprecated);
diff --git a/tools/doc/html.js b/tools/doc/html.js
index ae2da58b7a0131..871a55baf4676c 100644
--- a/tools/doc/html.js
+++ b/tools/doc/html.js
@@ -261,6 +261,10 @@ function parseYAML(text) {
     html += `${added.description}${deprecated.description}\n`;
   }
 
+  if (meta.napiVersion) {
+    html += `<span>N-API version: ${meta.napiVersion.join(', ')}</span>\n`;
+  }
+
   html += '</div>';
   return html;
 }

From a5233c7e1737673dc060e4820cf55e2da96468c6 Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Tue, 3 Jul 2018 17:42:16 -0500
Subject: [PATCH 016/116] deps: cherry-pick 477df06 from upstream v8

Original commit message:

    [API] Expand BigInt API

    Provide a more complete BigInt API.

    Bug: v8:7712
    Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng
    Change-Id: Ic8562d616f3125deabdf8b52c7019b191bef0e07
    Reviewed-on: chromium-review.googlesource.com/1101198
    Commit-Queue: Yang Guo <yangguo@chromium.org>
    Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
    Reviewed-by: Yang Guo <yangguo@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#54122}

PR-URL: https://github.com/nodejs/node/pull/21644
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 common.gypi                     |   2 +-
 deps/v8/include/v8.h            |  42 ++++++++++++
 deps/v8/src/api.cc              |  43 ++++++++++++
 deps/v8/src/api.h               |   1 +
 deps/v8/src/counters.h          |   1 +
 deps/v8/src/objects/bigint.cc   |  64 ++++++++++++++++++
 deps/v8/src/objects/bigint.h    |   5 ++
 deps/v8/test/cctest/test-api.cc | 114 ++++++++++++++++++++++++++++++++
 8 files changed, 271 insertions(+), 1 deletion(-)

diff --git a/common.gypi b/common.gypi
index d25a434b03d433..65eb7caf575498 100644
--- a/common.gypi
+++ b/common.gypi
@@ -28,7 +28,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.13',
+    'v8_embedder_string': '-node.14',
 
     # Enable disassembler for `--print-code` v8 options
     'v8_enable_disassembler': 1,
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index ab77238a77f97f..fe8f5a383952f7 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -3048,6 +3048,48 @@ class V8_EXPORT Uint32 : public Integer {
 class V8_EXPORT BigInt : public Primitive {
  public:
   static Local<BigInt> New(Isolate* isolate, int64_t value);
+  static Local<BigInt> NewFromUnsigned(Isolate* isolate, uint64_t value);
+  /**
+   * Creates a new BigInt object using a specified sign bit and a
+   * specified list of digits/words.
+   * The resulting number is calculated as:
+   *
+   * (-1)^sign_bit * (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...)
+   */
+  static MaybeLocal<BigInt> NewFromWords(Local<Context> context, int sign_bit,
+                                         int word_count, const uint64_t* words);
+
+  /**
+   * Returns the value of this BigInt as an unsigned 64-bit integer.
+   * If `lossless` is provided, it will reflect whether the return value was
+   * truncated or wrapped around. In particular, it is set to `false` if this
+   * BigInt is negative.
+   */
+  uint64_t Uint64Value(bool* lossless = nullptr) const;
+
+  /**
+   * Returns the value of this BigInt as a signed 64-bit integer.
+   * If `lossless` is provided, it will reflect whether this BigInt was
+   * truncated or not.
+   */
+  int64_t Int64Value(bool* lossless = nullptr) const;
+
+  /**
+   * Returns the number of 64-bit words needed to store the result of
+   * ToWordsArray().
+   */
+  int WordCount() const;
+
+  /**
+   * Writes the contents of this BigInt to a specified memory location.
+   * `sign_bit` must be provided and will be set to 1 if this BigInt is
+   * negative.
+   * `*word_count` has to be initialized to the length of the `words` array.
+   * Upon return, it will be set to the actual number of words that would
+   * be needed to store this BigInt (i.e. the return value of `WordCount()`).
+   */
+  void ToWordsArray(int* sign_bit, int* word_count, uint64_t* words) const;
+
   V8_INLINE static BigInt* Cast(v8::Value* obj);
 
  private:
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc
index 8a0dfca02b9dcf..a7f6d00f6fabf7 100644
--- a/deps/v8/src/api.cc
+++ b/deps/v8/src/api.cc
@@ -8121,6 +8121,49 @@ Local<BigInt> v8::BigInt::New(Isolate* isolate, int64_t value) {
   return Utils::ToLocal(result);
 }
 
+Local<BigInt> v8::BigInt::NewFromUnsigned(Isolate* isolate, uint64_t value) {
+  CHECK(i::FLAG_harmony_bigint);
+  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  ENTER_V8_NO_SCRIPT_NO_EXCEPTION(internal_isolate);
+  i::Handle<i::BigInt> result = i::BigInt::FromUint64(internal_isolate, value);
+  return Utils::ToLocal(result);
+}
+
+MaybeLocal<BigInt> v8::BigInt::NewFromWords(Local<Context> context,
+                                            int sign_bit, int word_count,
+                                            const uint64_t* words) {
+  CHECK(i::FLAG_harmony_bigint);
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  ENTER_V8_NO_SCRIPT(isolate, context, BigInt, NewFromWords,
+                     MaybeLocal<BigInt>(), InternalEscapableScope);
+  i::MaybeHandle<i::BigInt> result =
+      i::BigInt::FromWords64(isolate, sign_bit, word_count, words);
+  has_pending_exception = result.is_null();
+  RETURN_ON_FAILED_EXECUTION(BigInt);
+  RETURN_ESCAPED(Utils::ToLocal(result.ToHandleChecked()));
+}
+
+uint64_t v8::BigInt::Uint64Value(bool* lossless) const {
+  i::Handle<i::BigInt> handle = Utils::OpenHandle(this);
+  return handle->AsUint64(lossless);
+}
+
+int64_t v8::BigInt::Int64Value(bool* lossless) const {
+  i::Handle<i::BigInt> handle = Utils::OpenHandle(this);
+  return handle->AsInt64(lossless);
+}
+
+int BigInt::WordCount() const {
+  i::Handle<i::BigInt> handle = Utils::OpenHandle(this);
+  return handle->Words64Count();
+}
+
+void BigInt::ToWordsArray(int* sign_bit, int* word_count,
+                          uint64_t* words) const {
+  i::Handle<i::BigInt> handle = Utils::OpenHandle(this);
+  return handle->ToWordsArray64(sign_bit, word_count, words);
+}
+
 void Isolate::ReportExternalAllocationLimitReached() {
   i::Heap* heap = reinterpret_cast<i::Isolate*>(this)->heap();
   if (heap->gc_state() != i::Heap::NOT_IN_GC) return;
diff --git a/deps/v8/src/api.h b/deps/v8/src/api.h
index d2e25ae4f72332..c67de0482df66c 100644
--- a/deps/v8/src/api.h
+++ b/deps/v8/src/api.h
@@ -114,6 +114,7 @@ class RegisteredExtension {
   V(Promise, JSPromise)                        \
   V(Primitive, Object)                         \
   V(PrimitiveArray, FixedArray)                \
+  V(BigInt, BigInt)                            \
   V(ScriptOrModule, Script)
 
 class Utils {
diff --git a/deps/v8/src/counters.h b/deps/v8/src/counters.h
index 3c674b0ae01539..3318055185521e 100644
--- a/deps/v8/src/counters.h
+++ b/deps/v8/src/counters.h
@@ -692,6 +692,7 @@ class RuntimeCallTimer final {
   V(ArrayBuffer_New)                                       \
   V(Array_CloneElementAt)                                  \
   V(Array_New)                                             \
+  V(BigInt_NewFromWords)                                   \
   V(BigInt64Array_New)                                     \
   V(BigUint64Array_New)                                    \
   V(BigIntObject_New)                                      \
diff --git a/deps/v8/src/objects/bigint.cc b/deps/v8/src/objects/bigint.cc
index 0ccc5930b728a4..66962033ffe8b0 100644
--- a/deps/v8/src/objects/bigint.cc
+++ b/deps/v8/src/objects/bigint.cc
@@ -2205,6 +2205,70 @@ Handle<BigInt> BigInt::FromUint64(Isolate* isolate, uint64_t n) {
   return MutableBigInt::MakeImmutable(result);
 }
 
+MaybeHandle<BigInt> BigInt::FromWords64(Isolate* isolate, int sign_bit,
+                                        int words64_count,
+                                        const uint64_t* words) {
+  if (words64_count < 0 || words64_count > kMaxLength / (64 / kDigitBits)) {
+    THROW_NEW_ERROR(isolate, NewRangeError(MessageTemplate::kBigIntTooBig),
+                    BigInt);
+  }
+  if (words64_count == 0) return MutableBigInt::Zero(isolate);
+  STATIC_ASSERT(kDigitBits == 64 || kDigitBits == 32);
+  int length = (64 / kDigitBits) * words64_count;
+  DCHECK_GT(length, 0);
+  if (kDigitBits == 32 && words[words64_count - 1] <= (1ULL << 32)) length--;
+
+  Handle<MutableBigInt> result;
+  if (!MutableBigInt::New(isolate, length).ToHandle(&result)) {
+    return MaybeHandle<BigInt>();
+  }
+
+  result->set_sign(sign_bit);
+  if (kDigitBits == 64) {
+    for (int i = 0; i < length; ++i) {
+      result->set_digit(i, static_cast<digit_t>(words[i]));
+    }
+  } else {
+    for (int i = 0; i < length; i += 2) {
+      digit_t lo = static_cast<digit_t>(words[i / 2]);
+      digit_t hi = static_cast<digit_t>(words[i / 2] >> 32);
+      result->set_digit(i, lo);
+      if (i + 1 < length) result->set_digit(i + 1, hi);
+    }
+  }
+
+  return MutableBigInt::MakeImmutable(result);
+}
+
+int BigInt::Words64Count() {
+  STATIC_ASSERT(kDigitBits == 64 || kDigitBits == 32);
+  return length() / (64 / kDigitBits) +
+         (kDigitBits == 32 && length() % 2 == 1 ? 1 : 0);
+}
+
+void BigInt::ToWordsArray64(int* sign_bit, int* words64_count,
+                            uint64_t* words) {
+  DCHECK_NE(sign_bit, nullptr);
+  DCHECK_NE(words64_count, nullptr);
+  *sign_bit = sign();
+  int available_words = *words64_count;
+  *words64_count = Words64Count();
+  if (available_words == 0) return;
+  DCHECK_NE(words, nullptr);
+
+  int len = length();
+  if (kDigitBits == 64) {
+    for (int i = 0; i < len && i < available_words; ++i) words[i] = digit(i);
+  } else {
+    for (int i = 0; i < len && available_words > 0; i += 2) {
+      uint64_t lo = digit(i);
+      uint64_t hi = (i + 1) < len ? digit(i + 1) : 0;
+      words[i / 2] = lo | (hi << 32);
+      available_words--;
+    }
+  }
+}
+
 uint64_t MutableBigInt::GetRawBits(BigIntBase* x, bool* lossless) {
   if (lossless != nullptr) *lossless = true;
   if (x->is_zero()) return 0;
diff --git a/deps/v8/src/objects/bigint.h b/deps/v8/src/objects/bigint.h
index 3899853955d91d..65ce808394452d 100644
--- a/deps/v8/src/objects/bigint.h
+++ b/deps/v8/src/objects/bigint.h
@@ -144,8 +144,13 @@ class V8_EXPORT_PRIVATE BigInt : public BigIntBase {
 
   static Handle<BigInt> FromInt64(Isolate* isolate, int64_t n);
   static Handle<BigInt> FromUint64(Isolate* isolate, uint64_t n);
+  static MaybeHandle<BigInt> FromWords64(Isolate* isolate, int sign_bit,
+                                         int words64_count,
+                                         const uint64_t* words);
   int64_t AsInt64(bool* lossless = nullptr);
   uint64_t AsUint64(bool* lossless = nullptr);
+  int Words64Count();
+  void ToWordsArray64(int* sign_bit, int* words64_count, uint64_t* words);
 
   DECL_CAST(BigInt)
   DECL_VERIFIER(BigInt)
diff --git a/deps/v8/test/cctest/test-api.cc b/deps/v8/test/cctest/test-api.cc
index d698c1a9e008a4..637dc7d2062f9a 100644
--- a/deps/v8/test/cctest/test-api.cc
+++ b/deps/v8/test/cctest/test-api.cc
@@ -27613,3 +27613,117 @@ TEST(WasmStreamingAbortNoReject) {
   streaming.Abort({});
   CHECK_EQ(streaming.GetPromise()->State(), v8::Promise::kPending);
 }
+
+TEST(BigIntAPI) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+  bool lossless;
+  uint64_t words1[10];
+  uint64_t words2[10];
+
+  {
+    Local<Value> bi = CompileRun("12n");
+    CHECK(bi->IsBigInt());
+
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(), 12);
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(&lossless), 12);
+    CHECK_EQ(lossless, true);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(), 12);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(&lossless), 12);
+    CHECK_EQ(lossless, true);
+  }
+
+  {
+    Local<Value> bi = CompileRun("-12n");
+    CHECK(bi->IsBigInt());
+
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(), static_cast<uint64_t>(-12));
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(&lossless),
+             static_cast<uint64_t>(-12));
+    CHECK_EQ(lossless, false);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(), -12);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(&lossless), -12);
+    CHECK_EQ(lossless, true);
+  }
+
+  {
+    Local<Value> bi = CompileRun("123456789012345678901234567890n");
+    CHECK(bi->IsBigInt());
+
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(), 14083847773837265618ULL);
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(&lossless),
+             14083847773837265618ULL);
+    CHECK_EQ(lossless, false);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(), -4362896299872285998LL);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(&lossless),
+             -4362896299872285998LL);
+    CHECK_EQ(lossless, false);
+  }
+
+  {
+    Local<Value> bi = CompileRun("-123456789012345678901234567890n");
+    CHECK(bi->IsBigInt());
+
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(), 4362896299872285998LL);
+    CHECK_EQ(bi.As<v8::BigInt>()->Uint64Value(&lossless),
+             4362896299872285998LL);
+    CHECK_EQ(lossless, false);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(), 4362896299872285998LL);
+    CHECK_EQ(bi.As<v8::BigInt>()->Int64Value(&lossless), 4362896299872285998LL);
+    CHECK_EQ(lossless, false);
+  }
+
+  {
+    Local<v8::BigInt> bi =
+        v8::BigInt::NewFromWords(env.local(), 0, 0, words1).ToLocalChecked();
+    CHECK_EQ(bi->Uint64Value(), 0);
+    CHECK_EQ(bi->WordCount(), 0);
+  }
+
+  {
+    TryCatch try_catch(isolate);
+    v8::MaybeLocal<v8::BigInt> bi = v8::BigInt::NewFromWords(
+        env.local(), 0, std::numeric_limits<int>::max(), words1);
+    CHECK(bi.IsEmpty());
+    CHECK(try_catch.HasCaught());
+  }
+
+  {
+    TryCatch try_catch(isolate);
+    v8::MaybeLocal<v8::BigInt> bi =
+        v8::BigInt::NewFromWords(env.local(), 0, -1, words1);
+    CHECK(bi.IsEmpty());
+    CHECK(try_catch.HasCaught());
+  }
+
+  {
+    TryCatch try_catch(isolate);
+    v8::MaybeLocal<v8::BigInt> bi =
+        v8::BigInt::NewFromWords(env.local(), 0, 1 << 30, words1);
+    CHECK(bi.IsEmpty());
+    CHECK(try_catch.HasCaught());
+  }
+
+  for (int sign_bit = 0; sign_bit <= 1; sign_bit++) {
+    words1[0] = 0xffffffff00000000ULL;
+    words1[1] = 0x00000000ffffffffULL;
+    v8::Local<v8::BigInt> bi =
+        v8::BigInt::NewFromWords(env.local(), sign_bit, 2, words1)
+            .ToLocalChecked();
+    CHECK_EQ(bi->Uint64Value(&lossless),
+             sign_bit ? static_cast<uint64_t>(-static_cast<int64_t>(words1[0]))
+                      : words1[0]);
+    CHECK_EQ(lossless, false);
+    CHECK_EQ(bi->Int64Value(&lossless), sign_bit
+                                            ? -static_cast<int64_t>(words1[0])
+                                            : static_cast<int64_t>(words1[0]));
+    CHECK_EQ(lossless, false);
+    CHECK_EQ(bi->WordCount(), 2);
+    int real_sign_bit;
+    int word_count = arraysize(words2);
+    bi->ToWordsArray(&real_sign_bit, &word_count, words2);
+    CHECK_EQ(real_sign_bit, sign_bit);
+    CHECK_EQ(word_count, 2);
+  }
+}

From f7aa22a0ebc089fdafbe2c56d4f8b9b495c02611 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 3 Jul 2018 15:55:33 -0700
Subject: [PATCH 017/116] doc: improve guide text for CI runs

Make the text about CI runs in the COLLABORATOR_GUIDE more concise. Add
information about Resume Build which should generally be preferred over
Rebuild.

PR-URL: https://github.com/nodejs/node/pull/21645
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
---
 COLLABORATOR_GUIDE.md | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/COLLABORATOR_GUIDE.md b/COLLABORATOR_GUIDE.md
index 238a72547247b6..8d50589afdd11d 100644
--- a/COLLABORATOR_GUIDE.md
+++ b/COLLABORATOR_GUIDE.md
@@ -199,14 +199,10 @@ status indicator.
 
 Do not land any Pull Requests without passing (green or yellow) CI runs. If you
 believe any failed (red or grey) CI sub-tasks are unrelated to the change in the
-Pull Request, you may re-run the sub-task to try to see if it passes (just open
-the failed sub-task page and press the "Rebuild" button; be sure you are still
-logged in for this action). If re-runs of all failed sub-tasks pass (do not
-forget to provide the links for successfully rerun sub-tasks), it is permissible
-to land the Pull Request but only if the initial failures are believed in good
-faith to be unrelated to the changes in the Pull Request. Otherwise, reasonable
-steps must be taken to confirm that the changes are not resulting in an
-unreliable test.
+Pull Request, use "Resume Build" in the left navigation of the relevant
+`node-test-pull-request` job. It will create a new `node-test-pull-request` run
+that preserves all the green results from the current job but re-runs everything
+else.
 
 #### Useful CI Jobs
 

From 9776f1cbef855cbc6bb70c57e7747f931f64062d Mon Sep 17 00:00:00 2001
From: Kenny Yuan <kaining.yuan@intel.com>
Date: Wed, 27 Jun 2018 12:42:18 +0800
Subject: [PATCH 018/116] benchmark: add n-api function args benchmark

This benchmark suite is added to measure the performance of n-api
function call with various type/number of arguments. The cases in
this suite are carefully selected to efficiently show the performance
trend.

PR-URL: https://github.com/nodejs/node/pull/21555
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
---
 Makefile                                    |   9 +
 benchmark/napi/function_args/.gitignore     |   1 +
 benchmark/napi/function_args/binding.cc     | 142 ++++++++++++
 benchmark/napi/function_args/binding.gyp    |  12 +
 benchmark/napi/function_args/index.js       |  99 +++++++++
 benchmark/napi/function_args/napi_binding.c | 229 ++++++++++++++++++++
 6 files changed, 492 insertions(+)
 create mode 100644 benchmark/napi/function_args/.gitignore
 create mode 100644 benchmark/napi/function_args/binding.cc
 create mode 100644 benchmark/napi/function_args/binding.gyp
 create mode 100644 benchmark/napi/function_args/index.js
 create mode 100644 benchmark/napi/function_args/napi_binding.c

diff --git a/Makefile b/Makefile
index c75194dbaa1566..6bba4c5052574e 100644
--- a/Makefile
+++ b/Makefile
@@ -305,6 +305,15 @@ benchmark/napi/function_call/build/Release/binding.node: all \
 		--directory="$(shell pwd)/benchmark/napi/function_call" \
 		--nodedir="$(shell pwd)"
 
+benchmark/napi/function_args/build/Release/binding.node: all \
+		benchmark/napi/function_args/napi_binding.c \
+		benchmark/napi/function_args/binding.cc \
+		benchmark/napi/function_args/binding.gyp
+	$(NODE) deps/npm/node_modules/node-gyp/bin/node-gyp rebuild \
+		--python="$(PYTHON)" \
+		--directory="$(shell pwd)/benchmark/napi/function_args" \
+		--nodedir="$(shell pwd)"
+
 # Implicitly depends on $(NODE_EXE).  We don't depend on it explicitly because
 # it always triggers a rebuild due to it being a .PHONY rule.  See the comment
 # near the build-addons rule for more background.
diff --git a/benchmark/napi/function_args/.gitignore b/benchmark/napi/function_args/.gitignore
new file mode 100644
index 00000000000000..567609b1234a9b
--- /dev/null
+++ b/benchmark/napi/function_args/.gitignore
@@ -0,0 +1 @@
+build/
diff --git a/benchmark/napi/function_args/binding.cc b/benchmark/napi/function_args/binding.cc
new file mode 100644
index 00000000000000..11eb394a6a98f5
--- /dev/null
+++ b/benchmark/napi/function_args/binding.cc
@@ -0,0 +1,142 @@
+#include <v8.h>
+#include <node.h>
+#include <assert.h>
+
+using v8::Isolate;
+using v8::Context;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Value;
+using v8::Number;
+using v8::String;
+using v8::Object;
+using v8::Array;
+using v8::ArrayBufferView;
+using v8::ArrayBuffer;
+using v8::FunctionCallbackInfo;
+
+void CallWithString(const FunctionCallbackInfo<Value>& args) {
+  assert(args.Length() == 1 && args[0]->IsString());
+  if (args.Length() == 1 && args[0]->IsString()) {
+    Local<String> str = args[0].As<String>();
+    const int32_t length = str->Utf8Length() + 1;
+    char* buf = new char[length];
+    str->WriteUtf8(buf, length);
+    delete [] buf;
+  }
+}
+
+void CallWithArray(const FunctionCallbackInfo<Value>& args) {
+  assert(args.Length() == 1 && args[0]->IsArray());
+  if (args.Length() == 1 && args[0]->IsArray()) {
+    const Local<Array> array = args[0].As<Array>();
+    uint32_t length = array->Length();
+    for (uint32_t i = 0; i < length; ++ i) {
+      Local<Value> v;
+      v = array->Get(i);
+    }
+  }
+}
+
+void CallWithNumber(const FunctionCallbackInfo<Value>& args) {
+  assert(args.Length() == 1 && args[0]->IsNumber());
+  if (args.Length() == 1 && args[0]->IsNumber()) {
+    args[0].As<Number>()->Value();
+  }
+}
+
+void CallWithObject(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+
+  assert(args.Length() == 1 && args[0]->IsObject());
+  if (args.Length() == 1 && args[0]->IsObject()) {
+    Local<Object> obj = args[0].As<Object>();
+
+    MaybeLocal<String> map_key = String::NewFromUtf8(isolate,
+        "map", v8::NewStringType::kNormal);
+    assert(!map_key.IsEmpty());
+    MaybeLocal<Value> map_maybe = obj->Get(context,
+        map_key.ToLocalChecked());
+    assert(!map_maybe.IsEmpty());
+    Local<Value> map;
+    map = map_maybe.ToLocalChecked();
+
+    MaybeLocal<String> operand_key = String::NewFromUtf8(isolate,
+        "operand", v8::NewStringType::kNormal);
+    assert(!operand_key.IsEmpty());
+    MaybeLocal<Value> operand_maybe = obj->Get(context,
+        operand_key.ToLocalChecked());
+    assert(!operand_maybe.IsEmpty());
+    Local<Value> operand;
+    operand = operand_maybe.ToLocalChecked();
+
+    MaybeLocal<String> data_key = String::NewFromUtf8(isolate,
+        "data", v8::NewStringType::kNormal);
+    assert(!data_key.IsEmpty());
+    MaybeLocal<Value> data_maybe = obj->Get(context,
+        data_key.ToLocalChecked());
+    assert(!data_maybe.IsEmpty());
+    Local<Value> data;
+    data = data_maybe.ToLocalChecked();
+
+    MaybeLocal<String> reduce_key = String::NewFromUtf8(isolate,
+        "reduce", v8::NewStringType::kNormal);
+    assert(!reduce_key.IsEmpty());
+    MaybeLocal<Value> reduce_maybe = obj->Get(context,
+        reduce_key.ToLocalChecked());
+    assert(!reduce_maybe.IsEmpty());
+    Local<Value> reduce;
+    reduce = reduce_maybe.ToLocalChecked();
+  }
+}
+
+void CallWithTypedarray(const FunctionCallbackInfo<Value>& args) {
+  assert(args.Length() == 1 && args[0]->IsArrayBufferView());
+  if (args.Length() == 1 && args[0]->IsArrayBufferView()) {
+    assert(args[0]->IsArrayBufferView());
+    Local<ArrayBufferView> view = args[0].As<ArrayBufferView>();
+    const size_t byte_offset = view->ByteOffset();
+    const size_t byte_length = view->ByteLength();
+    assert(byte_length > 0);
+    assert(view->HasBuffer());
+    Local<ArrayBuffer> buffer;
+    buffer = view->Buffer();
+    ArrayBuffer::Contents contents;
+    contents = buffer->GetContents();
+    const uint32_t* data = reinterpret_cast<uint32_t*>(
+        static_cast<uint8_t*>(contents.Data()) + byte_offset);
+    assert(data);
+  }
+}
+
+void CallWithArguments(const FunctionCallbackInfo<Value>& args) {
+  assert(args.Length() > 1 && args[0]->IsNumber());
+  if (args.Length() > 1 && args[0]->IsNumber()) {
+    int32_t loop = args[0].As<v8::Uint32>()->Value();
+    for (int32_t i = 1; i < loop; ++i) {
+      assert(i < args.Length());
+      assert(args[i]->IsUint32());
+      args[i].As<v8::Uint32>()->Value();
+    }
+  }
+}
+
+void Initialize(Local<Object> target) {
+  NODE_SET_METHOD(target, "callWithString", CallWithString);
+  NODE_SET_METHOD(target, "callWithLongString", CallWithString);
+
+  NODE_SET_METHOD(target, "callWithArray", CallWithArray);
+  NODE_SET_METHOD(target, "callWithLargeArray", CallWithArray);
+  NODE_SET_METHOD(target, "callWithHugeArray", CallWithArray);
+
+  NODE_SET_METHOD(target, "callWithNumber", CallWithNumber);
+  NODE_SET_METHOD(target, "callWithObject", CallWithObject);
+  NODE_SET_METHOD(target, "callWithTypedarray", CallWithTypedarray);
+
+  NODE_SET_METHOD(target, "callWith10Numbers", CallWithArguments);
+  NODE_SET_METHOD(target, "callWith100Numbers", CallWithArguments);
+  NODE_SET_METHOD(target, "callWith1000Numbers", CallWithArguments);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
diff --git a/benchmark/napi/function_args/binding.gyp b/benchmark/napi/function_args/binding.gyp
new file mode 100644
index 00000000000000..ac122ed1a07962
--- /dev/null
+++ b/benchmark/napi/function_args/binding.gyp
@@ -0,0 +1,12 @@
+{
+  'targets': [
+    {
+      'target_name': 'napi_binding',
+      'sources': [ 'napi_binding.c' ]
+    },
+    {
+      'target_name': 'binding',
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/benchmark/napi/function_args/index.js b/benchmark/napi/function_args/index.js
new file mode 100644
index 00000000000000..c8f281a3429fde
--- /dev/null
+++ b/benchmark/napi/function_args/index.js
@@ -0,0 +1,99 @@
+// show the difference between calling a V8 binding C++ function
+// relative to a comparable N-API C++ function,
+// in various types/numbers of arguments.
+// Reports n of calls per second.
+'use strict';
+
+const common = require('../../common.js');
+
+let v8;
+let napi;
+
+try {
+  v8 = require('./build/Release/binding');
+} catch (err) {
+  // eslint-disable-next-line no-path-concat
+  console.error(__filename + ': V8 Binding failed to load');
+  process.exit(0);
+}
+
+try {
+  napi = require('./build/Release/napi_binding');
+} catch (err) {
+  // eslint-disable-next-line no-path-concat
+  console.error(__filename + ': NAPI-Binding failed to load');
+  process.exit(0);
+}
+
+const argsTypes = ['String', 'Number', 'Object', 'Array', 'Typedarray',
+                   '10Numbers', '100Numbers', '1000Numbers'];
+
+const generateArgs = (argType) => {
+  let args = [];
+
+  if (argType === 'String') {
+    args.push('The quick brown fox jumps over the lazy dog');
+  } else if (argType === 'LongString') {
+    args.push(Buffer.alloc(32768, '42').toString());
+  } else if (argType === 'Number') {
+    args.push(Math.floor(314158964 * Math.random()));
+  } else if (argType === 'Object') {
+    args.push({
+      map: 'add',
+      operand: 10,
+      data: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      reduce: 'add',
+    });
+  } else if (argType === 'Array') {
+    const arr = [];
+    for (let i = 0; i < 50; ++i) {
+      arr.push(Math.random() * 10e9);
+    }
+    args.push(arr);
+  } else if (argType === 'Typedarray') {
+    const arr = new Uint32Array(1000);
+    for (let i = 0; i < 1000; ++i) {
+      arr[i] = Math.random() * 4294967296;
+    }
+    args.push(arr);
+  } else if (argType === '10Numbers') {
+    args.push(10);
+    for (let i = 0; i < 9; ++i) {
+      args = [...args, ...generateArgs('Number')];
+    }
+  } else if (argType === '100Numbers') {
+    args.push(100);
+    for (let i = 0; i < 99; ++i) {
+      args = [...args, ...generateArgs('Number')];
+    }
+  } else if (argType === '1000Numbers') {
+    args.push(1000);
+    for (let i = 0; i < 999; ++i) {
+      args = [...args, ...generateArgs('Number')];
+    }
+  }
+
+  return args;
+};
+
+const bench = common.createBenchmark(main, {
+  type: argsTypes,
+  engine: ['v8', 'napi'],
+  n: [1, 1e1, 1e2, 1e3, 1e4, 1e5],
+});
+
+function main({ n, engine, type }) {
+  const bindings = engine === 'v8' ? v8 : napi;
+  const methodName = 'callWith' + type;
+  const fn = bindings[methodName];
+
+  if (fn) {
+    const args = generateArgs(type);
+
+    bench.start();
+    for (var i = 0; i < n; i++) {
+      fn.apply(null, args);
+    }
+    bench.end(n);
+  }
+}
diff --git a/benchmark/napi/function_args/napi_binding.c b/benchmark/napi/function_args/napi_binding.c
new file mode 100644
index 00000000000000..b697644ca441e9
--- /dev/null
+++ b/benchmark/napi/function_args/napi_binding.c
@@ -0,0 +1,229 @@
+#include <node_api.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+static napi_value CallWithString(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+
+  napi_valuetype types[1];
+  status = napi_typeof(env, args[0], types);
+  assert(status == napi_ok);
+
+  assert(types[0] == napi_string);
+  if (types[0] == napi_string) {
+    size_t len = 0;
+    // Get the length
+    status = napi_get_value_string_utf8(env, args[0], NULL, 0, &len);
+    assert(status == napi_ok);
+    char* buf = (char*)malloc(len + 1);
+    status = napi_get_value_string_utf8(env, args[0], buf, len + 1, &len);
+    assert(status == napi_ok);
+    free(buf);
+  }
+
+  return NULL;
+}
+
+static napi_value CallWithArray(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+
+  napi_value array = args[0];
+  bool is_array = false;
+  status = napi_is_array(env, array, &is_array);
+  assert(status == napi_ok);
+
+  assert(is_array);
+  if (is_array) {
+    uint32_t length;
+    status = napi_get_array_length(env, array, &length);
+    assert(status == napi_ok);
+
+    for (uint32_t i = 0; i < length; ++i) {
+      napi_value v;
+      status = napi_get_element(env, array, i, &v);
+      assert(status == napi_ok);
+    }
+  }
+
+  return NULL;
+}
+
+static napi_value CallWithNumber(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+
+  napi_valuetype types[1];
+  status = napi_typeof(env, args[0], types);
+  assert(status == napi_ok);
+
+  assert(types[0] == napi_number);
+  if (types[0] == napi_number) {
+    double value = 0.0;
+    status = napi_get_value_double(env, args[0], &value);
+    assert(status == napi_ok);
+  }
+
+  return NULL;
+}
+
+static napi_value CallWithObject(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+
+  napi_valuetype types[1];
+  status = napi_typeof(env, args[0], types);
+  assert(status == napi_ok);
+
+  assert(argc == 1 && types[0] == napi_object);
+  if (argc == 1 && types[0] == napi_object) {
+    napi_value value;
+
+    status = napi_get_named_property(env, args[0], "map", &value);
+    assert(status == napi_ok);
+
+    status = napi_get_named_property(env, args[0], "operand", &value);
+    assert(status == napi_ok);
+
+    status = napi_get_named_property(env, args[0], "data", &value);
+    assert(status == napi_ok);
+
+    status = napi_get_named_property(env, args[0], "reduce", &value);
+    assert(status == napi_ok);
+  }
+
+  return NULL;
+}
+
+static napi_value CallWithTypedarray(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+
+  bool is_typedarray = false;
+  status = napi_is_typedarray(env, args[0], &is_typedarray);
+  assert(status == napi_ok);
+
+  assert(is_typedarray);
+  if (is_typedarray) {
+    napi_typedarray_type type;
+    napi_value input_buffer;
+    size_t byte_offset = 0;
+    size_t length = 0;
+    status = napi_get_typedarray_info(env, args[0], &type, &length,
+        NULL, &input_buffer, &byte_offset);
+    assert(status == napi_ok);
+    assert(length > 0);
+
+    void* data = NULL;
+    size_t byte_length = 0;
+    status = napi_get_arraybuffer_info(env,
+        input_buffer, &data, &byte_length);
+    assert(status == napi_ok);
+
+    uint32_t* input_integers = (uint32_t*)((uint8_t*)(data) + byte_offset);
+    assert(input_integers);
+  }
+
+  return NULL;
+}
+
+static napi_value CallWithArguments(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc = 1;
+  napi_value args[1000];
+  // Get the length
+  status = napi_get_cb_info(env, info, &argc, NULL, NULL, NULL);
+  assert(status == napi_ok);
+
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  assert(status == napi_ok);
+  assert(argc <= 1000);
+
+  napi_valuetype types[1];
+  status = napi_typeof(env, args[0], types);
+  assert(status == napi_ok);
+
+  assert(argc > 1 && types[0] == napi_number);
+  if (argc > 1 && types[0] == napi_number) {
+    uint32_t loop = 0;
+    status = napi_get_value_uint32(env, args[0], &loop);
+    assert(status == napi_ok);
+
+    for (uint32_t i = 1; i < loop; ++i) {
+      assert(i < argc);
+      status = napi_typeof(env, args[i], types);
+      assert(status == napi_ok);
+      assert(types[0] == napi_number);
+
+      uint32_t value = 0;
+      status = napi_get_value_uint32(env, args[i], &value);
+      assert(status == napi_ok);
+    }
+  }
+
+  return NULL;
+}
+
+
+#define EXPORT_FUNC(env, exports, name, func)       \
+  do {                                              \
+    napi_status status;                             \
+    napi_value js_func;                             \
+    status = napi_create_function((env),            \
+                                  (name),           \
+                                  NAPI_AUTO_LENGTH, \
+                                  (func),           \
+                                  NULL,             \
+                                  &js_func);        \
+    assert(status == napi_ok);                      \
+    status = napi_set_named_property((env),         \
+                                     (exports),     \
+                                     (name),        \
+                                     js_func);      \
+    assert(status == napi_ok);                      \
+  } while (0);
+
+
+NAPI_MODULE_INIT() {
+  EXPORT_FUNC(env, exports, "callWithString", CallWithString);
+  EXPORT_FUNC(env, exports, "callWithLongString", CallWithString);
+
+  EXPORT_FUNC(env, exports, "callWithArray", CallWithArray);
+  EXPORT_FUNC(env, exports, "callWithLargeArray", CallWithArray);
+  EXPORT_FUNC(env, exports, "callWithHugeArray", CallWithArray);
+
+  EXPORT_FUNC(env, exports, "callWithNumber", CallWithNumber);
+
+  EXPORT_FUNC(env, exports, "callWithObject", CallWithObject);
+  EXPORT_FUNC(env, exports, "callWithTypedarray", CallWithTypedarray);
+
+  EXPORT_FUNC(env, exports, "callWith10Numbers", CallWithArguments);
+  EXPORT_FUNC(env, exports, "callWith100Numbers", CallWithArguments);
+  EXPORT_FUNC(env, exports, "callWith1000Numbers", CallWithArguments);
+
+  return exports;
+}

From c8d5bab022193625cf801b62b2e68fa066acc7d5 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 2 Jul 2018 18:20:06 -0400
Subject: [PATCH 019/116] doc: fix doc for napi_create_function

Merge the two duplicate entries for `napi_create_function()`.

Fixes: https://github.com/nodejs/node/issues/21606
PR-URL: https://github.com/nodejs/node/pull/21627/
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 doc/api/n-api.md | 44 ++++++++------------------------------------
 1 file changed, 8 insertions(+), 36 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 982b15f496893b..cdb3fcaf8276bf 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1485,40 +1485,6 @@ structure, in most cases using a `TypedArray` will suffice.
 
 For Node.js >=4 `Buffers` are `Uint8Array`s.
 
-#### napi_create_function
-<!-- YAML
-added: v8.0.0
-napiVersion: 1
--->
-```C
-napi_status napi_create_function(napi_env env,
-                                 const char* utf8name,
-                                 size_t length,
-                                 napi_callback cb,
-                                 void* data,
-                                 napi_value* result)
-```
-
-- `[in] env`: The environment that the API is invoked under.
-- `[in] utf8name`: A string representing the name of the function encoded as
-UTF8.
-- `[in] length`: The length of the `utf8name` in bytes, or
-`NAPI_AUTO_LENGTH` if it is null-terminated.
-- `[in] cb`: A function pointer to the native function to be invoked when the
-created function is invoked from JavaScript.
-- `[in] data`: Optional arbitrary context data to be passed into the native
-function when it is invoked.
-- `[out] result`: A `napi_value` representing a JavaScript function.
-
-Returns `napi_ok` if the API succeeded.
-
-This API returns an N-API value corresponding to a JavaScript `Function` object.
-It's used to wrap native functions so that they can be invoked from JavaScript.
-
-JavaScript `Function`s are described in
-[Section 19.2](https://tc39.github.io/ecma262/#sec-function-objects)
-of the ECMAScript Language Specification.
-
 #### napi_create_object
 <!-- YAML
 added: v8.0.0
@@ -3153,6 +3119,7 @@ napiVersion: 1
 ```C
 napi_status napi_create_function(napi_env env,
                                  const char* utf8name,
+                                 size_t length,
                                  napi_callback cb,
                                  void* data,
                                  napi_value* result);
@@ -3161,6 +3128,8 @@ napi_status napi_create_function(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] utf8Name`: The name of the function encoded as UTF8. This is visible
 within JavaScript as the new function object's `name` property.
+- `[in] length`: The length of the `utf8name` in bytes, or
+`NAPI_AUTO_LENGTH` if it is null-terminated.
 - `[in] cb`: The native function which should be called when this function
 object is invoked.
 - `[in] data`: User-provided data context. This will be passed back into the
@@ -3209,10 +3178,13 @@ const myaddon = require('./addon');
 myaddon.sayHello();
 ```
 
-The string passed to require is not necessarily the name passed into
-`NAPI_MODULE` in the earlier snippet but the name of the target in `binding.gyp`
+The string passed to `require()` is the name of the target in `binding.gyp`
 responsible for creating the `.node` file.
 
+JavaScript `Function`s are described in
+[Section 19.2](https://tc39.github.io/ecma262/#sec-function-objects)
+of the ECMAScript Language Specification.
+
 ### napi_get_cb_info
 <!-- YAML
 added: v8.0.0

From 04eed2342d8e51d12041541ca88a70ff83b9fad9 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 3 Jul 2018 16:51:28 -0700
Subject: [PATCH 020/116] doc: remove "note that" from fs doc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove "note that" from the fs documentation, along with other minor
nearby improvements.

Before:

    Note that some characters are obscured by Strong Bad's head.

After:

    Some characters are obscured by Strong Bad's head.

PR-URL: https://github.com/nodejs/node/pull/21646
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/fs.md | 118 ++++++++++++++++++++++++--------------------------
 1 file changed, 56 insertions(+), 62 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 2adbf6fb58cb7b..e159ec573c6664 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -45,9 +45,9 @@ try {
 }
 ```
 
-Note that there is no guaranteed ordering when using asynchronous methods.
-So the following is prone to error because the `fs.stat()` operation may
-complete before the `fs.rename()` operation.
+There is no guaranteed ordering when using asynchronous methods. So the
+following is prone to error because the `fs.stat()` operation may complete
+before the `fs.rename()` operation:
 
 ```js
 fs.rename('/tmp/hello', '/tmp/world', (err) => {
@@ -150,8 +150,8 @@ fs.open(Buffer.from('/open/some/file.txt'), 'r', (err, fd) => {
 });
 ```
 
-*Note:* On Windows Node.js follows the concept of per-drive working directory.
-This behavior can be observed when using a drive path without a backslash. For
+On Windows, Node.js follows the concept of per-drive working directory. This
+behavior can be observed when using a drive path without a backslash. For
 example `fs.readdirSync('c:\\')` can potentially return a different result than
 `fs.readdirSync('c:')`. For more information, see
 [this MSDN page][MSDN-Rel-Path].
@@ -278,9 +278,9 @@ eventually cause an application to crash.
 
 ## Threadpool Usage
 
-Note that all file system APIs except `fs.FSWatcher()` and those that are
-explicitly synchronous use libuv's threadpool, which can have surprising and
-negative performance implications for some applications, see the
+All file system APIs except `fs.FSWatcher()` and those that are explicitly
+synchronous use libuv's threadpool, which can have surprising and negative
+performance implications for some applications. See the
 [`UV_THREADPOOL_SIZE`][] documentation for more information.
 
 ## Class: fs.FSWatcher
@@ -689,15 +689,13 @@ The times in the stat object have the following semantics:
 * `birthtime` "Birth Time" - Time of file creation. Set once when the
   file is created. On filesystems where birthtime is not available,
   this field may instead hold either the `ctime` or
-  `1970-01-01T00:00Z` (ie, unix epoch timestamp `0`). Note that this
-  value may be greater than `atime` or `mtime` in this case. On Darwin
-  and other FreeBSD variants, also set if the `atime` is explicitly
-  set to an earlier value than the current `birthtime` using the
-  utimes(2) system call.
+  `1970-01-01T00:00Z` (ie, unix epoch timestamp `0`). This value may be greater
+  than `atime` or `mtime` in this case. On Darwin and other FreeBSD variants,
+  also set if the `atime` is explicitly set to an earlier value than the current
+  `birthtime` using the utimes(2) system call.
 
-Prior to Node.js v0.12, the `ctime` held the `birthtime` on Windows
-systems. Note that as of v0.12, `ctime` is not "creation time", and
-on Unix systems, it never was.
+Prior to Node.js 0.12, the `ctime` held the `birthtime` on Windows systems. As
+of 0.12, `ctime` is not "creation time", and on Unix systems, it never was.
 
 ## Class: fs.WriteStream
 <!-- YAML
@@ -1117,11 +1115,10 @@ For example, the octal value `0o765` means:
 * The group may read and write the file.
 * Others may read and execute the file.
 
-Note: When using raw numbers where file modes are expected,
-any value larger than `0o777` may result in platform-specific
-behaviors that are not supported to work consistently.
-Therefore constants like `S_ISVTX`, `S_ISGID` or `S_ISUID` are
-not exposed in `fs.constants`.
+When using raw numbers where file modes are expected, any value larger than
+`0o777` may result in platform-specific behaviors that are not supported to work
+consistently. Therefore constants like `S_ISVTX`, `S_ISGID` or `S_ISUID` are not
+exposed in `fs.constants`.
 
 Caveats: on Windows only the write permission can be changed, and the
 distinction among the permissions of group, owner or others is not
@@ -1373,8 +1370,8 @@ The `encoding` can be any one of those accepted by [`Buffer`][].
 
 If `fd` is specified, `ReadStream` will ignore the `path` argument and will use
 the specified file descriptor. This means that no `'open'` event will be
-emitted. Note that `fd` should be blocking; non-blocking `fd`s should be passed
-to [`net.Socket`][].
+emitted. `fd` should be blocking; non-blocking `fd`s should be passed to
+[`net.Socket`][].
 
 If `autoClose` is false, then the file descriptor won't be closed, even if
 there's an error. It is the application's responsibility to close it and make
@@ -1437,8 +1434,8 @@ file descriptor leak.
 
 Like [`ReadStream`][], if `fd` is specified, [`WriteStream`][] will ignore the
 `path` argument and will use the specified file descriptor. This means that no
-`'open'` event will be emitted. Note that `fd` should be blocking; non-blocking
-`fd`s should be passed to [`net.Socket`][].
+`'open'` event will be emitted. `fd` should be blocking; non-blocking `fd`s
+should be passed to [`net.Socket`][].
 
 If `options` is a string, then it specifies the encoding.
 
@@ -1468,11 +1465,11 @@ fs.exists('/etc/passwd', (exists) => {
 });
 ```
 
-**Note that the parameter to this callback is not consistent with other
-Node.js callbacks.** Normally, the first parameter to a Node.js callback is
-an `err` parameter, optionally followed by other parameters. The
-`fs.exists()` callback has only one boolean parameter. This is one reason
-`fs.access()` is recommended instead of `fs.exists()`.
+**The parameters for this callback are not consistent with other Node.js
+callbacks.** Normally, the first parameter to a Node.js callback is an `err`
+parameter, optionally followed by other parameters. The `fs.exists()` callback
+has only one boolean parameter. This is one reason `fs.access()` is recommended
+instead of `fs.exists()`.
 
 Using `fs.exists()` to check for the existence of a file before calling
 `fs.open()`, `fs.readFile()` or `fs.writeFile()` is not recommended. Doing
@@ -1568,10 +1565,9 @@ changes:
 Synchronous version of [`fs.exists()`][].
 Returns `true` if the path exists, `false` otherwise.
 
-Note that `fs.exists()` is deprecated, but `fs.existsSync()` is not.
-(The `callback` parameter to `fs.exists()` accepts parameters that are
-inconsistent with other Node.js callbacks. `fs.existsSync()` does not use
-a callback.)
+`fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`
+parameter to `fs.exists()` accepts parameters that are inconsistent with other
+Node.js callbacks. `fs.existsSync()` does not use a callback.
 
 ## fs.fchmod(fd, mode, callback)
 <!-- YAML
@@ -2144,9 +2140,8 @@ fs.mkdtemp(tmpDir, (err, folder) => {
   if (err) throw err;
   console.log(folder);
   // Will print something similar to `/tmpabc123`.
-  // Note that a new temporary directory is created
-  // at the file system root rather than *within*
-  // the /tmp directory.
+  // A new temporary directory is created at the file system root
+  // rather than *within* the /tmp directory.
 });
 
 // This method is *CORRECT*:
@@ -2199,8 +2194,8 @@ changes:
 Asynchronous file open. See open(2).
 
 `mode` sets the file mode (permission and sticky bits), but only if the file was
-created. Note that on Windows only the write permission can be manipulated,
-see [`fs.chmod()`][].
+created. On Windows, only the write permission can be manipulated; see
+[`fs.chmod()`][].
 
 The callback gets two arguments `(err, fd)`.
 
@@ -2838,9 +2833,9 @@ changes:
 Asynchronous symlink(2). No arguments other than a possible exception are given
 to the completion callback. The `type` argument can be set to `'dir'`,
 `'file'`, or `'junction'` and is only available on
-Windows (ignored on other platforms). Note that Windows junction points require
-the destination path to be absolute. When using `'junction'`, the `target`
-argument will automatically be normalized to absolute path.
+Windows (ignored on other platforms). Windows junction points require the
+destination path to be absolute. When using `'junction'`, the `target` argument
+will automatically be normalized to absolute path.
 
 Here is an example below:
 
@@ -3081,10 +3076,10 @@ The listener callback gets two arguments `(eventType, filename)`. `eventType`
 is either `'rename'` or `'change'`, and `filename` is the name of the file
 which triggered the event.
 
-Note that on most platforms, `'rename'` is emitted whenever a filename appears
-or disappears in the directory.
+On most platforms, `'rename'` is emitted whenever a filename appears or
+disappears in the directory.
 
-Also note the listener callback is attached to the `'change'` event fired by
+The listener callback is attached to the `'change'` event fired by
 [`fs.FSWatcher`][], but it is not the same thing as the `'change'` value of
 `eventType`.
 
@@ -3261,9 +3256,8 @@ The callback will be given three arguments `(err, bytesWritten, buffer)` where
 If this method is invoked as its [`util.promisify()`][]ed version, it returns
 a `Promise` for an `Object` with `bytesWritten` and `buffer` properties.
 
-Note that it is unsafe to use `fs.write` multiple times on the same file
-without waiting for the callback. For this scenario,
-`fs.createWriteStream` is strongly recommended.
+It is unsafe to use `fs.write()` multiple times on the same file without waiting
+for the callback. For this scenario, `fs.createWriteStream()` is recommended.
 
 On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
@@ -3305,12 +3299,12 @@ the current position. See pwrite(2).
 `encoding` is the expected string encoding.
 
 The callback will receive the arguments `(err, written, string)` where `written`
-specifies how many _bytes_ the passed string required to be written. Note that
-bytes written is not the same as string characters. See [`Buffer.byteLength`][].
+specifies how many _bytes_ the passed string required to be written. Bytes
+written is not necessarily the same as string characters written. See
+[`Buffer.byteLength`][].
 
-Note that it is unsafe to use `fs.write` multiple times on the same file
-without waiting for the callback. For this scenario,
-`fs.createWriteStream` is strongly recommended.
+It is unsafe to use `fs.write()` multiple times on the same file without waiting
+for the callback. For this scenario, `fs.createWriteStream()` is recommended.
 
 On Linux, positional writes don't work when the file is opened in append mode.
 The kernel ignores the position argument and always appends the data to
@@ -3367,9 +3361,9 @@ fs.writeFile('message.txt', 'Hello Node.js', 'utf8', callback);
 
 Any specified file descriptor has to support writing.
 
-Note that it is unsafe to use `fs.writeFile` multiple times on the same file
-without waiting for the callback. For this scenario,
-`fs.createWriteStream` is strongly recommended.
+It is unsafe to use `fs.writeFile()` multiple times on the same file without
+waiting for the callback. For this scenario, `fs.createWriteStream()` is
+recommended.
 
 If a file descriptor is specified as the `file`, it will not be closed
 automatically.
@@ -4156,9 +4150,9 @@ Creates a symbolic link then resolves the `Promise` with no arguments upon
 success.
 
 The `type` argument is only used on Windows platforms and can be one of `'dir'`,
-`'file'`, or `'junction'`. Note that Windows junction
-points require the destination path to be absolute. When using `'junction'`,
-the `target` argument will automatically be normalized to absolute path.
+`'file'`, or `'junction'`. Windows junction points require the destination path
+to be absolute. When using `'junction'`, the `target` argument will
+automatically be normalized to absolute path.
 
 ### fsPromises.truncate(path[, len])
 <!-- YAML
@@ -4520,9 +4514,9 @@ string:
   skipping the potentially stale local cache. It has a very real impact on
   I/O performance so using this flag is not recommended unless it is needed.
 
-  Note that this doesn't turn `fs.open()` or `fsPromises.open()` into a
-  synchronous blocking call. If synchronous operation is desired, something
-  like `fs.openSync()` should be used.
+  This doesn't turn `fs.open()` or `fsPromises.open()` into a synchronous
+  blocking call. If synchronous operation is desired, something like
+  `fs.openSync()` should be used.
 
 * `'w'` - Open file for writing.
   The file is created (if it does not exist) or truncated (if it exists).

From 214c608208bf7a94fa41a04af2761f9aa299b0ee Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Sun, 1 Jul 2018 12:55:49 +0300
Subject: [PATCH 021/116] tools: lint doc code examples in strict mode

PR-URL: https://github.com/nodejs/node/pull/21615
Refs: https://github.com/eslint/eslint-plugin-markdown#strict
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 .eslintrc.js       | 5 +++++
 doc/.eslintrc.yaml | 1 -
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index c076ba7979a2b9..742f9ea6d38ef9 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -40,6 +40,11 @@ module.exports = {
       ],
       parserOptions: { sourceType: 'module' },
     },
+    {
+      files: ['**/*.md'],
+      parserOptions: { ecmaFeatures: { impliedStrict: true } },
+      rules: { strict: 'off' },
+    },
   ],
   rules: {
     // ESLint built-in rules
diff --git a/doc/.eslintrc.yaml b/doc/.eslintrc.yaml
index 7b38afec10276a..49c4f4f64736c7 100644
--- a/doc/.eslintrc.yaml
+++ b/doc/.eslintrc.yaml
@@ -5,7 +5,6 @@ rules:
   no-restricted-properties: off
   no-undef: off
   no-unused-vars: off
-  strict: off
   symbol-description: off
 
   # add new ECMAScript features gradually

From 034fe19862e8dfb91cbc83ff7efc3d2f1be36aa6 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 19 Jun 2018 22:14:31 -0700
Subject: [PATCH 022/116] doc: add links to inline HTML table

Links in crypto.md table have been autolinking, but correct
Markdown processing will not autolink in block elements like tables.
Upcoming marked 0.4.0 will not autolink in this instance, so add the
links as anchor elements.

PR-URL: https://github.com/nodejs/node/pull/21678
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/crypto.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 4aea48ed2c61b1..8482c80ce6110d 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2412,7 +2412,7 @@ The following constants exported by `crypto.constants` apply to various uses of
 the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
 
 ### OpenSSL Options
-
+<!--lint disable maximum-line-length-->
 <table>
   <tr>
     <th>Constant</th>
@@ -2421,20 +2421,20 @@ the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
   <tr>
     <td><code>SSL_OP_ALL</code></td>
     <td>Applies multiple bug workarounds within OpenSSL. See
-    https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for
-    detail.</td>
+    <a href="https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html">https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html</a>
+    for detail.</td>
   </tr>
   <tr>
     <td><code>SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION</code></td>
     <td>Allows legacy insecure renegotiation between OpenSSL and unpatched
     clients or servers. See
-    https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.</td>
+    <a href="https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html">https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html</a>.</td>
   </tr>
   <tr>
     <td><code>SSL_OP_CIPHER_SERVER_PREFERENCE</code></td>
     <td>Attempts to use the server's preferences instead of the client's when
     selecting a cipher. Behavior depends on protocol version. See
-    https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html.</td>
+    <a href="https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html">https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html</a>.</td>
   </tr>
   <tr>
     <td><code>SSL_OP_CISCO_ANYCONNECT</code></td>
@@ -2568,6 +2568,7 @@ the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
 </table>
 
 ### OpenSSL Engine Constants
+<!--lint enable maximum-line-length remark-lint-->
 
 <table>
   <tr>

From 24f649c8cf69a86f6e982d55b016497ef56d6273 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Wed, 4 Jul 2018 09:55:55 -0700
Subject: [PATCH 023/116] test: fix pummel/test-net-connect-memleak
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A loop that generates a long array is resulting in a RangeError. Moving
to Array.prototype.fill() along with the ** operator instead of using a
loop fixes the issue.

PR-URL: https://github.com/nodejs/node/pull/21658
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/pummel/test-net-connect-memleak.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/pummel/test-net-connect-memleak.js b/test/pummel/test-net-connect-memleak.js
index b6a31daed230d5..7546a6caeb62ea 100644
--- a/test/pummel/test-net-connect-memleak.js
+++ b/test/pummel/test-net-connect-memleak.js
@@ -37,8 +37,7 @@ let before = 0;
 {
   // 2**26 == 64M entries
   global.gc();
-  let junk = [0];
-  for (let i = 0; i < 26; ++i) junk = junk.concat(junk);
+  const junk = new Array(2 ** 26).fill(0);
   before = process.memoryUsage().rss;
 
   net.createConnection(common.PORT, '127.0.0.1', function() {

From 971679328ec89554b314e88308c6e7523653c4da Mon Sep 17 00:00:00 2001
From: Shelley Vohr <shelley.vohr@gmail.com>
Date: Sat, 7 Jul 2018 13:13:49 -0700
Subject: [PATCH 024/116] doc: add codebytere as collaborator

PR-URL: https://github.com/nodejs/node/pull/21700
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Bryan English <bryan@bryanenglish.com>
---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index cd30238a94f293..e81f6629ed342a 100644
--- a/README.md
+++ b/README.md
@@ -345,6 +345,8 @@ For more information about the governance of the Node.js project, see
 **Colin Ihrig** &lt;cjihrig@gmail.com&gt;
 * [claudiorodriguez](https://github.com/claudiorodriguez) -
 **Claudio Rodriguez** &lt;cjrodr@yahoo.com&gt;
+* [codebytere](https://github.com/codebytere) -
+**Shelley Vohr** &lt;codebytere@gmail.com&gt; (she/her)
 * [danbev](https://github.com/danbev) -
 **Daniel Bevenius** &lt;daniel.bevenius@gmail.com&gt;
 * [DavidCai1993](https://github.com/DavidCai1993) -

From 1044bafec4e08a2725eb98048a8b8e0af9588dd5 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sat, 7 Jul 2018 13:53:24 -0700
Subject: [PATCH 025/116] doc: remove _Node.js style callback_

We refer to them only as _error-first callbacks_ in our docs. We don't
call them _Node.js style callbacks_ so let's take this opporutnity to
keep things a bit more concise

PR-URL: https://github.com/nodejs/node/pull/21701
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
---
 doc/api/errors.md | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/doc/api/errors.md b/doc/api/errors.md
index 41a61c48c3166a..a122bc51e39ca6 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -127,12 +127,11 @@ exactly how errors raised by those methods are propagated.
 <!--type=misc-->
 
 Most asynchronous methods exposed by the Node.js core API follow an idiomatic
-pattern referred to as an _error-first callback_ (sometimes referred to as
-a _Node.js style callback_). With this pattern, a callback function is passed
-to the method as an argument. When the operation either completes or an error
-is raised, the callback function is called with
-the `Error` object (if any) passed as the first argument. If no error was
-raised, the first argument will be passed as `null`.
+pattern referred to as an _error-first callback_. With this pattern, a callback
+function is passed to the method as an argument. When the operation either
+completes or an error is raised, the callback function is called with the
+`Error` object (if any) passed as the first argument. If no error was raised,
+the first argument will be passed as `null`.
 
 ```js
 const fs = require('fs');

From dc848587871fe3f8c8e1ed8c2c89ade62c062c7c Mon Sep 17 00:00:00 2001
From: MaleDong <maledong_private@qq.com>
Date: Fri, 22 Jun 2018 19:08:58 +0800
Subject: [PATCH 026/116] test,util: add missing tests and conditions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1) Add missing unit tests by `ucs-2` in different kinds of cases.
2) Add missing unit tests by `usc-2` in different kinds of cases.
3) Fix a bug：We cannot find `ucs-2` in `case 5`'s `if` condition after
`toLowerCase()`

PR-URL: https://github.com/nodejs/node/pull/21455
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 benchmark/util/normalize-encoding.js          | 25 +++++++++++++------
 lib/internal/util.js                          |  3 ++-
 .../test-internal-util-normalizeencoding.js   |  7 ++++++
 3 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/benchmark/util/normalize-encoding.js b/benchmark/util/normalize-encoding.js
index 96eab1912d0761..65cf5b1b0ce18c 100644
--- a/benchmark/util/normalize-encoding.js
+++ b/benchmark/util/normalize-encoding.js
@@ -4,18 +4,25 @@ const common = require('../common.js');
 const assert = require('assert');
 
 const groupedInputs = {
-  group_common: ['undefined', 'utf8', 'utf-8', 'base64', 'binary', 'latin1'],
-  group_upper: ['UTF-8', 'UTF8', 'UCS2', 'UTF-16LE', 'UTF16LE', 'BASE64'],
-  group_uncommon: [ 'foo', '1', 'false', 'undefined', '[]'],
+  group_common: ['undefined', 'utf8', 'utf-8', 'base64',
+                 'binary', 'latin1', 'ucs-2', 'usc-2'],
+  group_upper: ['UTF-8', 'UTF8', 'UCS2', 'UTF-16LE',
+                'UTF16LE', 'BASE64', 'UCS-2', 'USC-2'],
+  group_uncommon: ['foo', '1', 'false', 'undefined', '[]', '{}'],
   group_misc: ['', 'utf16le', 'usc2', 'hex', 'HEX', 'BINARY']
 };
 
 const inputs = [
-  '', 'utf8', 'utf-8', 'UTF-8',
-  'UTF8', 'Utf8', 'uTf-8', 'utF-8', 'ucs2',
-  'UCS2', 'utf16le', 'utf-16le', 'UTF-16LE', 'UTF16LE',
+  '',
+  'utf8', 'utf-8', 'UTF-8',
+  'UTF8', 'Utf8', 'uTf-8', 'utF-8',
+  'ucs2', 'UCS2', 'UcS2',
+  'USC2', 'usc2', 'uSc2',
+  'ucs-2', 'UCS-2', 'UcS-2',
+  'usc-2', 'USC-2', 'uSc-2',
+  'utf16le', 'utf-16le', 'UTF-16LE', 'UTF16LE',
   'binary', 'BINARY', 'latin1', 'base64', 'BASE64',
-  'hex', 'HEX', 'foo', '1', 'false', 'undefined', '[]'];
+  'hex', 'HEX', 'foo', '1', 'false', 'undefined', '[]', '{}'];
 
 const bench = common.createBenchmark(main, {
   input: inputs.concat(Object.keys(groupedInputs)),
@@ -42,6 +49,8 @@ function getInput(input) {
       return [undefined];
     case '[]':
       return [[]];
+    case '{}':
+      return [{}];
     default:
       return [input];
   }
@@ -53,7 +62,7 @@ function main({ input, n }) {
   var noDead = '';
 
   bench.start();
-  for (var i = 0; i < n; i += 1) {
+  for (var i = 0; i < n; ++i) {
     for (var j = 0; j < inputs.length; ++j) {
       noDead = normalizeEncoding(inputs[j]);
     }
diff --git a/lib/internal/util.js b/lib/internal/util.js
index 07515e2e090daa..bc513e7fedf79e 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -115,7 +115,7 @@ function slowCases(enc) {
       if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';
       enc = `${enc}`.toLowerCase();
       if (enc === 'utf8') return 'utf8';
-      if (enc === 'ucs2' || enc === 'UCS2') return 'utf16le';
+      if (enc === 'ucs2') return 'utf16le';
       break;
     case 3:
       if (enc === 'hex' || enc === 'HEX' || `${enc}`.toLowerCase() === 'hex')
@@ -131,6 +131,7 @@ function slowCases(enc) {
       if (enc === 'utf-8') return 'utf8';
       if (enc === 'ascii') return 'ascii';
       if (enc === 'usc-2') return 'utf16le';
+      if (enc === 'ucs-2') return 'utf16le';
       break;
     case 6:
       if (enc === 'base64') return 'base64';
diff --git a/test/parallel/test-internal-util-normalizeencoding.js b/test/parallel/test-internal-util-normalizeencoding.js
index 081255cef02f2a..2f16d55fad247c 100644
--- a/test/parallel/test-internal-util-normalizeencoding.js
+++ b/test/parallel/test-internal-util-normalizeencoding.js
@@ -18,10 +18,16 @@ const tests = [
   ['utF-8', 'utf8'],
   ['ucs2', 'utf16le'],
   ['UCS2', 'utf16le'],
+  ['ucs-2', 'utf16le'],
+  ['UCS-2', 'utf16le'],
+  ['UcS-2', 'utf16le'],
   ['utf16le', 'utf16le'],
   ['utf-16le', 'utf16le'],
   ['UTF-16LE', 'utf16le'],
   ['UTF16LE', 'utf16le'],
+  ['usc-2', 'utf16le'],
+  ['USC-2', 'utf16le'],
+  ['uSc-2', 'utf16le'],
   ['binary', 'latin1'],
   ['BINARY', 'latin1'],
   ['latin1', 'latin1'],
@@ -36,6 +42,7 @@ const tests = [
   [NaN, undefined],
   [0, undefined],
   [[], undefined],
+  [{}, undefined]
 ];
 
 tests.forEach((e, i) => {

From 109c59971a6be7bd4dbde15e443e743a78e771d9 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 6 Jul 2018 10:47:48 -0400
Subject: [PATCH 027/116] n-api: create functions directly

Avoid using `v8::FunctionTemplate::New()` when using
`v8::Function::New()` suffices. This ensures that individual functions
can be gc-ed and that functions can be created dynamically without
running out of memory.

PR-URL: https://github.com/nodejs/node/pull/21688
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Yang Guo <yangguo@chromium.org>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 src/node_api.cc                               | 20 +++--
 test/addons-napi/test_function/test.js        |  8 +-
 .../addons-napi/test_function/test_function.c | 84 +++++++++++++++++++
 3 files changed, 103 insertions(+), 9 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 2b14617175c167..1d42435264cfec 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1025,11 +1025,11 @@ napi_status napi_create_function(napi_env env,
 
   RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
 
-  v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
-      isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
-
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::MaybeLocal<v8::Function> maybe_function = tpl->GetFunction(context);
+  v8::MaybeLocal<v8::Function> maybe_function =
+      v8::Function::New(context,
+                        v8impl::FunctionCallbackWrapper::Invoke,
+                        cbdata);
   CHECK_MAYBE_EMPTY(env, maybe_function, napi_generic_failure);
 
   return_value = scope.Escape(maybe_function.ToLocalChecked());
@@ -1491,13 +1491,17 @@ napi_status napi_define_properties(napi_env env,
       v8::Local<v8::Value> cbdata =
           v8impl::CreateFunctionCallbackData(env, p->method, p->data);
 
-      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
+      CHECK_MAYBE_EMPTY(env, cbdata, napi_generic_failure);
+
+      v8::MaybeLocal<v8::Function> maybe_fn =
+          v8::Function::New(context,
+                            v8impl::FunctionCallbackWrapper::Invoke,
+                            cbdata);
 
-      v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
-          isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
+      CHECK_MAYBE_EMPTY(env, maybe_fn, napi_generic_failure);
 
       auto define_maybe = obj->DefineOwnProperty(
-        context, property_name, t->GetFunction(), attributes);
+        context, property_name, maybe_fn.ToLocalChecked(), attributes);
 
       if (!define_maybe.FromMaybe(false)) {
         return napi_set_last_error(env, napi_generic_failure);
diff --git a/test/addons-napi/test_function/test.js b/test/addons-napi/test_function/test.js
index 752e9965b23039..6f0f1681752a2c 100644
--- a/test/addons-napi/test_function/test.js
+++ b/test/addons-napi/test_function/test.js
@@ -1,11 +1,12 @@
 'use strict';
+// Flags: --expose-gc
+
 const common = require('../../common');
 const assert = require('assert');
 
 // testing api calls for function
 const test_function = require(`./build/${common.buildType}/test_function`);
 
-
 function func1() {
   return 1;
 }
@@ -29,3 +30,8 @@ assert.strictEqual(test_function.TestCall(func4, 1), 2);
 
 assert.strictEqual(test_function.TestName.name, 'Name');
 assert.strictEqual(test_function.TestNameShort.name, 'Name_');
+
+let tracked_function = test_function.MakeTrackedFunction(common.mustCall());
+assert(!!tracked_function);
+tracked_function = null;
+global.gc();
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 2c361933cfa071..068999a6e5bc5c 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -30,6 +30,78 @@ static napi_value TestFunctionName(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
+static void finalize_function(napi_env env, void* data, void* hint) {
+  napi_ref ref = data;
+
+  // Retrieve the JavaScript undefined value.
+  napi_value undefined;
+  NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
+
+  // Retrieve the JavaScript function we must call.
+  napi_value js_function;
+  NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, ref, &js_function));
+
+  // Call the JavaScript function to indicate that the generated JavaScript
+  // function is about to be gc-ed.
+  NAPI_CALL_RETURN_VOID(env, napi_call_function(env,
+                                                undefined,
+                                                js_function,
+                                                0,
+                                                NULL,
+                                                NULL));
+
+  // Destroy the persistent reference to the function we just called so as to
+  // properly clean up.
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, ref));
+}
+
+static napi_value MakeTrackedFunction(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value js_finalize_cb;
+  napi_valuetype arg_type;
+
+  // Retrieve and validate from the arguments the function we will use to
+  // indicate to JavaScript that the function we are about to create is about to
+  // be gc-ed.
+  NAPI_CALL(env, napi_get_cb_info(env,
+                                  info,
+                                  &argc,
+                                  &js_finalize_cb,
+                                  NULL,
+                                  NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+  NAPI_CALL(env, napi_typeof(env, js_finalize_cb, &arg_type));
+  NAPI_ASSERT(env, arg_type == napi_function, "Argument must be a function");
+
+  // Dynamically create a function.
+  napi_value result;
+  NAPI_CALL(env, napi_create_function(env,
+                                      "TrackedFunction",
+                                      NAPI_AUTO_LENGTH,
+                                      TestFunctionName,
+                                      NULL,
+                                      &result));
+
+  // Create a strong reference to the function we will call when the tracked
+  // function is about to be gc-ed.
+  napi_ref js_finalize_cb_ref;
+  NAPI_CALL(env, napi_create_reference(env,
+                                       js_finalize_cb,
+                                       1,
+                                       &js_finalize_cb_ref));
+
+  // Attach a finalizer to the dynamically created function and pass it the
+  // strong reference we created in the previous step.
+  NAPI_CALL(env, napi_wrap(env,
+                           result,
+                           js_finalize_cb_ref,
+                           finalize_function,
+                           NULL,
+                           NULL));
+
+  return result;
+}
+
 static napi_value Init(napi_env env, napi_value exports) {
   napi_value fn1;
   NAPI_CALL(env, napi_create_function(
@@ -43,9 +115,21 @@ static napi_value Init(napi_env env, napi_value exports) {
   NAPI_CALL(env, napi_create_function(
       env, "Name_extra", 5, TestFunctionName, NULL, &fn3));
 
+  napi_value fn4;
+  NAPI_CALL(env, napi_create_function(env,
+                                      "MakeTrackedFunction",
+                                      NAPI_AUTO_LENGTH,
+                                      MakeTrackedFunction,
+                                      NULL,
+                                      &fn4));
+
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestCall", fn1));
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestName", fn2));
   NAPI_CALL(env, napi_set_named_property(env, exports, "TestNameShort", fn3));
+  NAPI_CALL(env, napi_set_named_property(env,
+                                         exports,
+                                         "MakeTrackedFunction",
+                                         fn4));
 
   return exports;
 }

From b8ba003fbfd4395d2c815d30504d80d60bf71fd2 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 5 Jul 2018 22:24:17 -0400
Subject: [PATCH 028/116] n-api: remove experimental gate from status codes

Re: https://github.com/nodejs/node/pull/21226#discussion_r200534431
PR-URL: https://github.com/nodejs/node/pull/21680
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 src/node_api_types.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/node_api_types.h b/src/node_api_types.h
index af7d7c7f95331d..3854a32f011048 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -76,10 +76,8 @@ typedef enum {
   napi_escape_called_twice,
   napi_handle_scope_mismatch,
   napi_callback_scope_mismatch,
-#ifdef NAPI_EXPERIMENTAL
   napi_queue_full,
   napi_closing,
-#endif  // NAPI_EXPERIMENTAL
 } napi_status;
 
 #ifdef NAPI_EXPERIMENTAL

From cd77d8782a241f5b4e4d65c1f8852be57f8edbef Mon Sep 17 00:00:00 2001
From: iwko <iwoczerniawski@gmail.com>
Date: Sun, 10 Jun 2018 15:28:00 +0200
Subject: [PATCH 029/116] doc: improve documentation of fs sync methods

Add links to async methods and make wording consistent.

PR-URL: https://github.com/nodejs/node/pull/21243
Refs: https://github.com/nodejs/node/issues/21197
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Jamie Davis <davisjam@vt.edu>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/fs.md | 63 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 48 insertions(+), 15 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index e159ec573c6664..872820a991f170 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1137,8 +1137,8 @@ changes:
 * `path` {string|Buffer|URL}
 * `mode` {integer}
 
-Synchronously changes the permissions of a file. Returns `undefined`.
-This is the synchronous version of [`fs.chmod()`][].
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.chmod()`][].
 
 See also: chmod(2).
 
@@ -1562,13 +1562,16 @@ changes:
 * `path` {string|Buffer|URL}
 * Returns: {boolean}
 
-Synchronous version of [`fs.exists()`][].
 Returns `true` if the path exists, `false` otherwise.
 
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.exists()`][].
+
 `fs.exists()` is deprecated, but `fs.existsSync()` is not. The `callback`
 parameter to `fs.exists()` accepts parameters that are inconsistent with other
 Node.js callbacks. `fs.existsSync()` does not use a callback.
 
+
 ## fs.fchmod(fd, mode, callback)
 <!-- YAML
 added: v0.4.7
@@ -1815,7 +1818,10 @@ added: v0.8.6
 * `fd` {integer}
 * `len` {integer} **Default:** `0`
 
-Synchronous ftruncate(2). Returns `undefined`.
+Returns `undefined`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.ftruncate()`][].
 
 ## fs.futimes(fd, atime, mtime, callback)
 <!-- YAML
@@ -2165,8 +2171,10 @@ added: v5.10.0
   * `encoding` {string} **Default:** `'utf8'`
 * Returns: {string}
 
-The synchronous version of [`fs.mkdtemp()`][]. Returns the created
-folder path.
+Returns the created folder path.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.mkdtemp()`][].
 
 The optional `options` argument can be a string specifying an encoding, or an
 object with an `encoding` property specifying the character encoding to use.
@@ -2222,8 +2230,10 @@ changes:
 * `mode` {integer} **Default:** `0o666`
 * Returns: {number}
 
-Synchronous version of [`fs.open()`][]. Returns an integer representing the file
-descriptor.
+Returns an integer representing the file descriptor.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.open()`][].
 
 ## fs.read(fd, buffer, offset, length, position, callback)
 <!-- YAML
@@ -2421,7 +2431,10 @@ changes:
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'r'`.
 * Returns: {string|Buffer}
 
-Synchronous version of [`fs.readFile()`][]. Returns the contents of the `path`.
+Returns the contents of the `path`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.readFile()`][].
 
 If the `encoding` option is specified then this function returns a
 string. Otherwise it returns a buffer.
@@ -2509,7 +2522,10 @@ changes:
 * `position` {integer}
 * Returns: {number}
 
-Synchronous version of [`fs.read()`][]. Returns the number of `bytesRead`.
+Returns the number of `bytesRead`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.read()`][].
 
 ## fs.realpath(path[, options], callback)
 <!-- YAML
@@ -2624,7 +2640,10 @@ changes:
   * `encoding` {string} **Default:** `'utf8'`
 * Returns: {string|Buffer}
 
-Synchronous version of [`fs.realpath()`][]. Returns the resolved pathname.
+Returns the resolved pathname.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.realpath()`][].
 
 ## fs.realpathSync.native(path[, options])
 <!-- YAML
@@ -2860,7 +2879,10 @@ changes:
 * `path` {string|Buffer|URL}
 * `type` {string} **Default:** `'file'`
 
-Synchronous symlink(2). Returns `undefined`.
+Returns `undefined`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.symlink()`][].
 
 ## fs.truncate(path[, len], callback)
 <!-- YAML
@@ -3036,7 +3058,10 @@ changes:
 * `atime` {integer}
 * `mtime` {integer}
 
-Synchronous version of [`fs.utimes()`][]. Returns `undefined`.
+Returns `undefined`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.utimes()`][].
 
 ## fs.watch(filename[, options][, listener])
 <!-- YAML
@@ -3387,7 +3412,10 @@ changes:
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
 
-The synchronous version of [`fs.writeFile()`][]. Returns `undefined`.
+Returns `undefined`.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.writeFile()`][].
 
 ## fs.writeSync(fd, buffer[, offset[, length[, position]]])
 <!-- YAML
@@ -3423,7 +3451,10 @@ changes:
 * `encoding` {string}
 * Returns: {number}
 
-Synchronous versions of [`fs.write()`][]. Returns the number of bytes written.
+Returns the number of bytes written.
+
+For detailed information, see the documentation of the asynchronous version of
+this API: [`fs.write()`][].
 
 ## fs Promises API
 
@@ -4588,6 +4619,7 @@ the file contents.
 [`fs.copyFile()`]: #fs_fs_copyfile_src_dest_flags_callback
 [`fs.exists()`]: fs.html#fs_fs_exists_path_callback
 [`fs.fstat()`]: #fs_fs_fstat_fd_options_callback
+[`fs.ftruncate()`]: #fs_fs_ftruncate_fd_len_callback
 [`fs.futimes()`]: #fs_fs_futimes_fd_atime_mtime_callback
 [`fs.lstat()`]: #fs_fs_lstat_path_options_callback
 [`fs.mkdir()`]: #fs_fs_mkdir_path_mode_callback
@@ -4599,6 +4631,7 @@ the file contents.
 [`fs.realpath()`]: #fs_fs_realpath_path_options_callback
 [`fs.rmdir()`]: #fs_fs_rmdir_path_callback
 [`fs.stat()`]: #fs_fs_stat_path_options_callback
+[`fs.symlink()`]: #fs_fs_symlink_target_path_type_callback
 [`fs.utimes()`]: #fs_fs_utimes_path_atime_mtime_callback
 [`fs.watch()`]: #fs_fs_watch_filename_options_listener
 [`fs.write()`]: #fs_fs_write_fd_buffer_offset_length_position_callback

From 194d1955a77d1011368c8802599a0aa5b122ac4d Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 5 Jul 2018 22:49:55 -0700
Subject: [PATCH 030/116] test: fix test-tls-connect-memleak

A loop that generates a long array is resulting in a RangeError. Moving
to Array.prototype.fill() along with the ** operator instead of using a
loop fixes the issue.

PR-URL: https://github.com/nodejs/node/pull/21681
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
---
 test/pummel/test-tls-connect-memleak.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/test/pummel/test-tls-connect-memleak.js b/test/pummel/test-tls-connect-memleak.js
index 1ef131d6876ac4..6809b23baf3926 100644
--- a/test/pummel/test-tls-connect-memleak.js
+++ b/test/pummel/test-tls-connect-memleak.js
@@ -44,9 +44,7 @@ tls.createServer({
 
 {
   // 2**26 == 64M entries
-  let junk = [0];
-
-  for (let i = 0; i < 26; ++i) junk = junk.concat(junk);
+  const junk = new Array(2 ** 26).fill(0);
 
   const options = { rejectUnauthorized: false };
   tls.connect(common.PORT, '127.0.0.1', options, function() {

From eda7fffba419b770fe74c4726cc1d22336baa0f4 Mon Sep 17 00:00:00 2001
From: Sohail Rajdev <sohailrajdev97@gmail.com>
Date: Wed, 4 Jul 2018 23:10:03 +0530
Subject: [PATCH 031/116] test: swap arguments in strictEqual()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit also comments the third argument

PR-URL: https://github.com/nodejs/node/pull/21660
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 test/pummel/test-timers.js | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/test/pummel/test-timers.js b/test/pummel/test-timers.js
index 7e0492a6425b7d..a6766b7a33c11d 100644
--- a/test/pummel/test-timers.js
+++ b/test/pummel/test-timers.js
@@ -31,7 +31,7 @@ let interval_count = 0;
 clearTimeout(null);
 clearInterval(null);
 
-assert.strictEqual(true, setTimeout instanceof Function);
+assert.strictEqual(setTimeout instanceof Function, true);
 const starttime = new Date();
 setTimeout(common.mustCall(function() {
   const endtime = new Date();
@@ -40,7 +40,7 @@ setTimeout(common.mustCall(function() {
   assert.ok(diff > 0);
   console.error(`diff: ${diff}`);
 
-  assert.strictEqual(true, 1000 - WINDOW < diff && diff < 1000 + WINDOW);
+  assert.strictEqual(1000 - WINDOW < diff && diff < 1000 + WINDOW, true);
 }), 1000);
 
 // this timer shouldn't execute
@@ -57,9 +57,9 @@ setInterval(function() {
 
   const t = interval_count * 1000;
 
-  assert.strictEqual(true, t - WINDOW < diff && diff < t + WINDOW);
+  assert.strictEqual(t - WINDOW < diff && diff < t + WINDOW, true);
 
-  assert.strictEqual(true, interval_count <= 3);
+  assert.strictEqual(interval_count <= 3, true);
   if (interval_count === 3)
     clearInterval(this);
 }, 1000);
@@ -67,13 +67,13 @@ setInterval(function() {
 
 // Single param:
 setTimeout(function(param) {
-  assert.strictEqual('test param', param);
+  assert.strictEqual(param, 'test param');
 }, 1000, 'test param');
 
 let interval_count2 = 0;
 setInterval(function(param) {
   ++interval_count2;
-  assert.strictEqual('test param', param);
+  assert.strictEqual(param, 'test param');
 
   if (interval_count2 === 3)
     clearInterval(this);
@@ -82,15 +82,15 @@ setInterval(function(param) {
 
 // Multiple param
 setTimeout(function(param1, param2) {
-  assert.strictEqual('param1', param1);
-  assert.strictEqual('param2', param2);
+  assert.strictEqual(param1, 'param1');
+  assert.strictEqual(param2, 'param2');
 }, 1000, 'param1', 'param2');
 
 let interval_count3 = 0;
 setInterval(function(param1, param2) {
   ++interval_count3;
-  assert.strictEqual('param1', param1);
-  assert.strictEqual('param2', param2);
+  assert.strictEqual(param1, 'param1');
+  assert.strictEqual(param2, 'param2');
 
   if (interval_count3 === 3)
     clearInterval(this);
@@ -120,8 +120,9 @@ clearTimeout(y);
 
 
 process.on('exit', function() {
-  assert.strictEqual(3, interval_count);
-  assert.strictEqual(11, count4);
-  assert.strictEqual(0, expectedTimeouts,
-                     'clearTimeout cleared too many timeouts');
+  assert.strictEqual(interval_count, 3);
+  assert.strictEqual(count4, 11);
+
+  // Check that the correct number of timers ran.
+  assert.strictEqual(expectedTimeouts, 0);
 });

From 11e9b4ecee63b25adaf2f1413fe2006d2f419d7f Mon Sep 17 00:00:00 2001
From: Niicck <niicck@users.noreply.github.com>
Date: Tue, 3 Jul 2018 22:32:54 -0500
Subject: [PATCH 032/116] test: fix parallel/test-tls-env-extra-ca.js

fix args in final assert.strictEqual() call

PR-URL: https://github.com/nodejs/node/pull/21647
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
---
 test/parallel/test-tls-env-extra-ca.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-tls-env-extra-ca.js b/test/parallel/test-tls-env-extra-ca.js
index c4f647a735d72f..b8ff1d3be237eb 100644
--- a/test/parallel/test-tls-env-extra-ca.js
+++ b/test/parallel/test-tls-env-extra-ca.js
@@ -39,6 +39,7 @@ const server = tls.createServer(options, common.mustCall(function(s) {
   });
 
   fork(__filename, { env }).on('exit', common.mustCall(function(status) {
-    assert.strictEqual(status, 0, 'client did not succeed in connecting');
+    // client did not succeed in connecting
+    assert.strictEqual(status, 0);
   }));
 }));

From 92d79212ec5a573c73d319c2860d1bcedfe75d5b Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Sat, 7 Jul 2018 15:24:38 -0400
Subject: [PATCH 033/116] lib: consolidate redundant require() calls
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21699
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
---
 lib/_http_outgoing.js                   | 4 +---
 lib/internal/crypto/random.js           | 3 +--
 lib/internal/http2/core.js              | 5 +++--
 lib/internal/modules/esm/translators.js | 5 +++--
 4 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index f075e0ecad7a2b..913935048680eb 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -25,12 +25,11 @@ const assert = require('assert').ok;
 const Stream = require('stream');
 const util = require('util');
 const internalUtil = require('internal/util');
-const internalHttp = require('internal/http');
+const { outHeadersKey, utcDate } = require('internal/http');
 const { Buffer } = require('buffer');
 const common = require('_http_common');
 const checkIsHttpToken = common._checkIsHttpToken;
 const checkInvalidHeaderChar = common._checkInvalidHeaderChar;
-const { outHeadersKey } = require('internal/http');
 const {
   defaultTriggerAsyncIdScope,
   symbols: { async_id_symbol }
@@ -48,7 +47,6 @@ const {
 } = require('internal/errors').codes;
 
 const { CRLF, debug } = common;
-const { utcDate } = internalHttp;
 
 const kIsCorked = Symbol('isCorked');
 
diff --git a/lib/internal/crypto/random.js b/lib/internal/crypto/random.js
index a30f8acdf27786..15fbc37c2239d7 100644
--- a/lib/internal/crypto/random.js
+++ b/lib/internal/crypto/random.js
@@ -1,7 +1,7 @@
 'use strict';
 
 const { AsyncWrap, Providers } = process.binding('async_wrap');
-const { Buffer } = require('buffer');
+const { Buffer, kMaxLength } = require('buffer');
 const { randomBytes: _randomBytes } = process.binding('crypto');
 const {
   ERR_INVALID_ARG_TYPE,
@@ -10,7 +10,6 @@ const {
 } = require('internal/errors').codes;
 const { isArrayBufferView } = require('internal/util/types');
 
-const { kMaxLength } = require('buffer');
 const kMaxUint32 = 2 ** 32 - 1;
 const kMaxPossibleLength = Math.min(kMaxLength, kMaxUint32);
 
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index bbbc3c21300a74..3ef01c836d9cb9 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -2,7 +2,8 @@
 
 /* eslint-disable no-use-before-define */
 
-require('internal/util').assertCrypto();
+const internalUtil = require('internal/util');
+internalUtil.assertCrypto();
 
 const { internalBinding } = require('internal/bootstrap/loaders');
 const { async_id_symbol } = require('internal/async_hooks').symbols;
@@ -71,7 +72,7 @@ const { utcDate } = require('internal/http');
 const {
   promisify,
   customInspectSymbol: kInspect
-} = require('internal/util');
+} = internalUtil;
 const { isArrayBufferView } = require('internal/util/types');
 const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
 const { _connectionListener: httpConnectionListener } = http;
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 476a420b8a9620..7785865d6573f9 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -14,8 +14,9 @@ const fs = require('fs');
 const { _makeLong } = require('path');
 const { SafeMap } = require('internal/safe_globals');
 const { URL } = require('url');
-const debug = require('util').debuglog('esm');
-const readFileAsync = require('util').promisify(fs.readFile);
+const util = require('util');
+const debug = util.debuglog('esm');
+const readFileAsync = util.promisify(fs.readFile);
 const readFileSync = fs.readFileSync;
 const StringReplace = Function.call.bind(String.prototype.replace);
 const JsonParse = JSON.parse;

From 6e1917a596c131a858353c7a4a440b5bfec14154 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=A1=D0=BA=D0=BE=D0=B2=D0=BE=D1=80=D0=BE=D0=B4=D0=B0=20?=
 =?UTF-8?q?=D0=9D=D0=B8=D0=BA=D0=B8=D1=82=D0=B0=20=D0=90=D0=BD=D0=B4=D1=80?=
 =?UTF-8?q?=D0=B5=D0=B5=D0=B2=D0=B8=D1=87?= <chalkerx@gmail.com>
Date: Sun, 1 Jul 2018 01:44:47 +0300
Subject: [PATCH 034/116] doc: update changelog with 9.x EOL
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This removes unsupported versions from the table, as those might confuse
people, execially given the
  > Release versions displayed in **bold** text represent the most
  > recent actively supported release.
remark below.

It was inconsistent to keep some of the EOL entries in the table while
removing others (v5.x, v7.x) -- this commit takes care of that.

Instead, release status is hinted in the branch list above, highlighting
two main branches -- Current and Active LTS.

Also update the link to the Release repo.

Refs: https://github.com/nodejs/Release/pull/351
PR-URL: https://github.com/nodejs/node/pull/21612
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
---
 CHANGELOG.md | 85 +++++++---------------------------------------------
 1 file changed, 11 insertions(+), 74 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2bc1a7eaf53e81..af54237dfa74d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,16 +8,16 @@ release lines.
 
 Select a Node.js version below to view the changelog history:
 
-* [Node.js 10](doc/changelogs/CHANGELOG_V10.md)
-* [Node.js 9](doc/changelogs/CHANGELOG_V9.md)
-* [Node.js 8](doc/changelogs/CHANGELOG_V8.md)
-* [Node.js 7](doc/changelogs/CHANGELOG_V7.md)
-* [Node.js 6](doc/changelogs/CHANGELOG_V6.md)
-* [Node.js 5](doc/changelogs/CHANGELOG_V5.md)
-* [Node.js 4](doc/changelogs/CHANGELOG_V4.md)
-* [io.js](doc/changelogs/CHANGELOG_IOJS.md)
-* [Node.js 0.12](doc/changelogs/CHANGELOG_V012.md)
-* [Node.js 0.10](doc/changelogs/CHANGELOG_V010.md)
+* [Node.js 10](doc/changelogs/CHANGELOG_V10.md) — **Current**
+* [Node.js 9](doc/changelogs/CHANGELOG_V9.md) — End-of-Life
+* [Node.js 8](doc/changelogs/CHANGELOG_V8.md) — **Long Term Support**
+* [Node.js 7](doc/changelogs/CHANGELOG_V7.md) — End-of-Life
+* [Node.js 6](doc/changelogs/CHANGELOG_V6.md) — Long Term Support
+* [Node.js 5](doc/changelogs/CHANGELOG_V5.md) — End-of-Life
+* [Node.js 4](doc/changelogs/CHANGELOG_V4.md) — End-of-Life
+* [io.js](doc/changelogs/CHANGELOG_IOJS.md) — End-of-Life
+* [Node.js 0.12](doc/changelogs/CHANGELOG_V012.md) — End-of-Life
+* [Node.js 0.10](doc/changelogs/CHANGELOG_V010.md) — End-of-Life
 * [Archive](doc/changelogs/CHANGELOG_ARCHIVE.md)
 
 Please use the following table to find the changelog for a specific Node.js
@@ -26,10 +26,8 @@ release.
 <table>
 <tr>
   <th title="Current"><a href="doc/changelogs/CHANGELOG_V10.md">10</a><sup>Current</sup></th>
-  <th><a href="doc/changelogs/CHANGELOG_V9.md">9</a></th>
   <th title="LTS Until 2019-12"><a href="doc/changelogs/CHANGELOG_V8.md">8</a><sup>LTS</sup></th>
   <th title="LTS Until 2019-04"><a href="doc/changelogs/CHANGELOG_V6.md">6</a><sup>LTS</sup></th>
-  <th title="End-of-life since 2018-05-01"><a href="doc/changelogs/CHANGELOG_V4.md">4</a><sup>EOL</sup></th>
 </tr>
 <tr>
     <td valign="top">
@@ -44,25 +42,6 @@ release.
 <a href="doc/changelogs/CHANGELOG_V10.md#10.0.0">10.0.0</a><br/>
     </td>
     <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V9.md#9.11.1">9.11.1</a></b><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.11.0">9.11.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.10.1">9.10.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.10.0">9.10.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.9.0">9.9.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.8.0">9.8.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.7.1">9.7.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.7.0">9.7.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.6.1">9.6.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.6.0">9.6.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.5.0">9.5.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.4.0">9.4.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.3.0">9.3.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.2.1">9.2.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.2.0">9.2.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.1.0">9.1.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V9.md#9.0.0">9.0.0</a><br/>
-    </td>
-    <td valign="top">
 <b><a href="doc/changelogs/CHANGELOG_V8.md#8.11.1">8.11.1</a></b><br/>
 <a href="doc/changelogs/CHANGELOG_V8.md#8.11.0">8.11.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V8.md#8.10.0">8.10.0</a><br/>
@@ -126,55 +105,13 @@ release.
 <a href="doc/changelogs/CHANGELOG_V6.md#6.1.0">6.1.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V6.md#6.0.0">6.0.0</a><br/>
   </td>
-  <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V4.md#4.9.1">4.9.1</a></b><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.9.0">4.9.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.7">4.8.7</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.6">4.8.6</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.5">4.8.5</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.4">4.8.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.3">4.8.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.2">4.8.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.1">4.8.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.8.0">4.8.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.7.3">4.7.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.7.2">4.7.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.7.1">4.7.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.7.0">4.7.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.6.1">4.6.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.6.1">4.6.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.6.0">4.6.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.5.0">4.5.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.7">4.4.7</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.6">4.4.6</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.5">4.4.5</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.4">4.4.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.3">4.4.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.2">4.4.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.1">4.4.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.4.0">4.4.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.3.2">4.3.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.3.1">4.3.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.3.0">4.3.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.6">4.2.6</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.5">4.2.5</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.4">4.2.4</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.3">4.2.3</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.2">4.2.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.1">4.2.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.2.0">4.2.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.1.2">4.1.2</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.1.1">4.1.1</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.1.0">4.1.0</a><br/>
-<a href="doc/changelogs/CHANGELOG_V4.md#4.0.0">4.0.0</a><br/>
-  </td>
 </tr>
 </table>
 
 ### Notes
 
 * Release streams marked with `LTS` are currently covered by the
-  [Node.js Long Term Support plan](https://github.com/nodejs/LTS).
+  [Node.js Long Term Support plan](https://github.com/nodejs/Release).
 * Release versions displayed in **bold** text represent the most
   recent actively supported release.
 

From 51db88b0f19c7906101897ed276e8d38a78bfa73 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=A1=D0=BA=D0=BE=D0=B2=D0=BE=D1=80=D0=BE=D0=B4=D0=B0=20?=
 =?UTF-8?q?=D0=9D=D0=B8=D0=BA=D0=B8=D1=82=D0=B0=20=D0=90=D0=BD=D0=B4=D1=80?=
 =?UTF-8?q?=D0=B5=D0=B5=D0=B2=D0=B8=D1=87?= <chalkerx@gmail.com>
Date: Sat, 23 Jun 2018 14:48:54 +0300
Subject: [PATCH 035/116] doc: fix http2stream.pushStream error doc

The old error code `ERR_HTTP2_STREAM_CLOSED` was removed in commit
0babd181a0c5d775e62a12b3b04fe4d7654fe80a (pull request #17406), and the
testcase for http2stream.pushStream was changed accordingly, but the
documentation change was overlooked.

This commit fixes it and aligns the documentation with the testcase.

This is a part of the fixes hinted by #21470, which includes some tests
for error codes usage and documentation and enforces a stricter format.

Refs: https://github.com/nodejs/node/pull/21470
Refs: https://github.com/nodejs/node/pull/17406
PR-URL: https://github.com/nodejs/node/pull/21487
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/http2.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/http2.md b/doc/api/http2.md
index 3e1850a6790b94..9f702de02b03cf 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -3143,7 +3143,7 @@ added: v8.4.0
 Call [`http2stream.pushStream()`][] with the given headers, and wraps the
 given newly created [`Http2Stream`] on `Http2ServerResponse`.
 
-The callback will be called with an error with code `ERR_HTTP2_STREAM_CLOSED`
+The callback will be called with an error with code `ERR_HTTP2_INVALID_STREAM`
 if the stream is closed.
 
 ## Collecting HTTP/2 Performance Metrics

From b758006c23803bb70caef47aae6cc76c19bf3b85 Mon Sep 17 00:00:00 2001
From: Masashi Hirano <cherrydog07@gmail.com>
Date: Thu, 21 Jun 2018 13:02:54 +0900
Subject: [PATCH 036/116] fs: fix fsPromises.lchmod error on non-Mac
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On non-macOS, fsPromises.lchmod throws AssertionError.
Expected behavior is `Error [ERR_METHOD_NOT_IMPLEMENTED]`.
`ERR_METHOD_NOT_IMPLEMENTED()` requires argument, but it wasn't set.

Fixes `ERR_METHOD_NOT_IMPLEMENTED()` to
`ERR_METHOD_NOT_IMPLEMENTED('lchmod()')`.

PR-URL: https://github.com/nodejs/node/pull/21435
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
---
 lib/internal/fs/promises.js       |  2 +-
 test/parallel/test-fs-promises.js | 15 +++++++++++++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index e567bf0731b5c7..a8d94a739e2bee 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -371,7 +371,7 @@ async function chmod(path, mode) {
 
 async function lchmod(path, mode) {
   if (O_SYMLINK === undefined)
-    throw new ERR_METHOD_NOT_IMPLEMENTED();
+    throw new ERR_METHOD_NOT_IMPLEMENTED('lchmod()');
 
   const fd = await open(path, O_WRONLY | O_SYMLINK);
   return fchmod(fd, mode).finally(fd.close.bind(fd));
diff --git a/test/parallel/test-fs-promises.js b/test/parallel/test-fs-promises.js
index 6871a6762b68e2..602f1191b7aef5 100644
--- a/test/parallel/test-fs-promises.js
+++ b/test/parallel/test-fs-promises.js
@@ -140,15 +140,26 @@ function verifyStatObject(stat) {
                          (await realpath(newLink)).toLowerCase());
       assert.strictEqual(newPath.toLowerCase(),
                          (await readlink(newLink)).toLowerCase());
+
+      const newMode = 0o666;
       if (common.isOSX) {
         // lchmod is only available on macOS
-        const newMode = 0o666;
         await lchmod(newLink, newMode);
         stats = await lstat(newLink);
         assert.strictEqual(stats.mode & 0o777, newMode);
+      } else {
+        await Promise.all([
+          assert.rejects(
+            lchmod(newLink, newMode),
+            common.expectsError({
+              code: 'ERR_METHOD_NOT_IMPLEMENTED',
+              type: Error,
+              message: 'The lchmod() method is not implemented'
+            })
+          )
+        ]);
       }
 
-
       await unlink(newLink);
     }
 

From 07160cd2fd1be238b8a99d1034f44c8202889171 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Fri, 6 Jul 2018 09:48:59 -0700
Subject: [PATCH 037/116] http2: order declarations in core.js

Order declarations:

* public modules in alphabetical order
* internal modules in alphabetical order
* process.binding() calls in alphabetical order
* exports in alphabetical order

PR-URL: https://github.com/nodejs/node/pull/21689
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/http2/core.js | 87 ++++++++++++++++++++------------------
 1 file changed, 45 insertions(+), 42 deletions(-)

diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index 3ef01c836d9cb9..5a4fa63335581d 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -2,22 +2,31 @@
 
 /* eslint-disable no-use-before-define */
 
-const internalUtil = require('internal/util');
-internalUtil.assertCrypto();
+const {
+  assertCrypto,
+  customInspectSymbol: kInspect,
+  promisify
+} = require('internal/util');
+
+assertCrypto();
 
-const { internalBinding } = require('internal/bootstrap/loaders');
-const { async_id_symbol } = require('internal/async_hooks').symbols;
-const { UV_EOF } = process.binding('uv');
-const http = require('http');
-const binding = process.binding('http2');
-const { FileHandle } = process.binding('fs');
-const { StreamPipe } = internalBinding('stream_pipe');
 const assert = require('assert');
 const EventEmitter = require('events');
+const fs = require('fs');
+const http = require('http');
 const net = require('net');
+const { Duplex } = require('stream');
 const tls = require('tls');
+const { URL } = require('url');
 const util = require('util');
-const fs = require('fs');
+
+const { kIncomingMessage } = require('_http_common');
+const { kServerResponse } = require('_http_server');
+const { StreamWrap } = require('_stream_wrap');
+
+const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
+const { async_id_symbol } = require('internal/async_hooks').symbols;
+const { internalBinding } = require('internal/bootstrap/loaders');
 const {
   codes: {
     ERR_HTTP2_ALTSVC_INVALID_ORIGIN,
@@ -61,30 +70,11 @@ const {
     ERR_SOCKET_CLOSED
   }
 } = require('internal/errors');
-const { StreamWrap } = require('_stream_wrap');
-const { Duplex } = require('stream');
-const { URL } = require('url');
+const { utcDate } = require('internal/http');
 const { onServerStream,
         Http2ServerRequest,
         Http2ServerResponse,
 } = require('internal/http2/compat');
-const { utcDate } = require('internal/http');
-const {
-  promisify,
-  customInspectSymbol: kInspect
-} = internalUtil;
-const { isArrayBufferView } = require('internal/util/types');
-const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
-const { _connectionListener: httpConnectionListener } = http;
-const { createPromise, promiseResolve } = process.binding('util');
-const debug = util.debuglog('http2');
-
-const kMaxFrameSize = (2 ** 24) - 1;
-const kMaxInt = (2 ** 32) - 1;
-const kMaxStreams = (2 ** 31) - 1;
-
-// eslint-disable-next-line no-control-regex
-const kQuotedString = /^[\x09\x20-\x5b\x5d-\x7e\x80-\xff]*$/;
 
 const {
   assertIsObject,
@@ -104,27 +94,40 @@ const {
   updateOptionsBuffer,
   updateSettingsBuffer
 } = require('internal/http2/util');
-
-const {
-  kTimeout,
-  setUnrefTimeout,
-  validateTimerDuration
-} = require('internal/timers');
 const {
   createWriteWrap,
   writeGeneric,
   writevGeneric
 } = require('internal/stream_base_commons');
+const {
+  kTimeout,
+  setUnrefTimeout,
+  validateTimerDuration
+} = require('internal/timers');
+const { isArrayBufferView } = require('internal/util/types');
 
+const { FileHandle } = process.binding('fs');
+const binding = process.binding('http2');
 const { ShutdownWrap } = process.binding('stream_wrap');
+const { createPromise, promiseResolve } = process.binding('util');
+const { UV_EOF } = process.binding('uv');
+
+const { StreamPipe } = internalBinding('stream_pipe');
+const { _connectionListener: httpConnectionListener } = http;
+const debug = util.debuglog('http2');
+
+const kMaxFrameSize = (2 ** 24) - 1;
+const kMaxInt = (2 ** 32) - 1;
+const kMaxStreams = (2 ** 31) - 1;
+
+// eslint-disable-next-line no-control-regex
+const kQuotedString = /^[\x09\x20-\x5b\x5d-\x7e\x80-\xff]*$/;
+
 const { constants, nameForErrorCode } = binding;
 
 const NETServer = net.Server;
 const TLSServer = tls.Server;
 
-const { kIncomingMessage } = require('_http_common');
-const { kServerResponse } = require('_http_server');
-
 const kAlpnProtocol = Symbol('alpnProtocol');
 const kAuthority = Symbol('authority');
 const kEncrypted = Symbol('encrypted');
@@ -2815,13 +2818,13 @@ function getUnpackedSettings(buf, options = {}) {
 
 // Exports
 module.exports = {
+  connect,
   constants,
+  createServer,
+  createSecureServer,
   getDefaultSettings,
   getPackedSettings,
   getUnpackedSettings,
-  createServer,
-  createSecureServer,
-  connect,
   Http2Session,
   Http2Stream,
   Http2ServerRequest,

From dae71309294f908cda4f4349472652eaddde0218 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 30 Jun 2018 13:35:58 +0200
Subject: [PATCH 038/116] zlib: track memory allocated by zlib
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Provide a custom memory allocator for zlib, and track
memory allocated by the library with it.

Right now this “only” makes reported external memory
usage (much) more accurate and protects against zlib
memory leaks, but it generally will enable us to give
more accurate memory usage statistics for zlib.

PR-URL: https://github.com/nodejs/node/pull/21608
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_zlib.cc | 77 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 64 insertions(+), 13 deletions(-)

diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 8e30241f4e6d45..893209d4d42012 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -34,6 +34,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
+#include <atomic>
 
 namespace node {
 
@@ -97,6 +98,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
   ~ZCtx() override {
     CHECK_EQ(false, write_in_progress_ && "write in progress");
     Close();
+    CHECK_EQ(zlib_memory_, 0);
+    CHECK_EQ(unreported_allocations_, 0);
   }
 
   void Close() {
@@ -109,17 +112,15 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
     CHECK(init_done_ && "close before init");
     CHECK_LE(mode_, UNZIP);
 
+    AllocScope alloc_scope(this);
     int status = Z_OK;
     if (mode_ == DEFLATE || mode_ == GZIP || mode_ == DEFLATERAW) {
       status = deflateEnd(&strm_);
-      int64_t change_in_bytes = -static_cast<int64_t>(kDeflateContextSize);
-      env()->isolate()->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
     } else if (mode_ == INFLATE || mode_ == GUNZIP || mode_ == INFLATERAW ||
                mode_ == UNZIP) {
       status = inflateEnd(&strm_);
-      int64_t change_in_bytes = -static_cast<int64_t>(kInflateContextSize);
-      env()->isolate()->AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
     }
+
     CHECK(status == Z_OK || status == Z_DATA_ERROR);
     mode_ = NONE;
 
@@ -165,6 +166,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
       CHECK(0 && "Invalid flush value");
     }
 
+    AllocScope alloc_scope(ctx);
+
     Bytef* in;
     Bytef* out;
     size_t in_off, in_len, out_off, out_len;
@@ -355,6 +358,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
 
   // v8 land!
   void AfterThreadPoolWork(int status) override {
+    AllocScope alloc_scope(this);
+
     write_in_progress_ = false;
 
     if (status == UV_ECANCELED) {
@@ -505,14 +510,15 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
                    int strategy, uint32_t* write_result,
                    Local<Function> write_js_callback, char* dictionary,
                    size_t dictionary_len) {
+    AllocScope alloc_scope(ctx);
     ctx->level_ = level;
     ctx->windowBits_ = windowBits;
     ctx->memLevel_ = memLevel;
     ctx->strategy_ = strategy;
 
-    ctx->strm_.zalloc = Z_NULL;
-    ctx->strm_.zfree = Z_NULL;
-    ctx->strm_.opaque = Z_NULL;
+    ctx->strm_.zalloc = AllocForZlib;
+    ctx->strm_.zfree = FreeForZlib;
+    ctx->strm_.opaque = static_cast<void*>(ctx);
 
     ctx->flush_ = Z_NO_FLUSH;
 
@@ -540,16 +546,12 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
                                  ctx->windowBits_,
                                  ctx->memLevel_,
                                  ctx->strategy_);
-        ctx->env()->isolate()
-            ->AdjustAmountOfExternalAllocatedMemory(kDeflateContextSize);
         break;
       case INFLATE:
       case GUNZIP:
       case INFLATERAW:
       case UNZIP:
         ctx->err_ = inflateInit2(&ctx->strm_, ctx->windowBits_);
-        ctx->env()->isolate()
-            ->AdjustAmountOfExternalAllocatedMemory(kInflateContextSize);
         break;
       default:
         UNREACHABLE();
@@ -605,6 +607,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
   }
 
   static void Params(ZCtx* ctx, int level, int strategy) {
+    AllocScope alloc_scope(ctx);
+
     ctx->err_ = Z_OK;
 
     switch (ctx->mode_) {
@@ -622,6 +626,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
   }
 
   void Reset() {
+    AllocScope alloc_scope(this);
+
     err_ = Z_OK;
 
     switch (mode_) {
@@ -660,8 +666,51 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
     }
   }
 
-  static const int kDeflateContextSize = 16384;  // approximate
-  static const int kInflateContextSize = 10240;  // approximate
+  // Allocation functions provided to zlib itself. We store the real size of
+  // the allocated memory chunk just before the "payload" memory we return
+  // to zlib.
+  // Because we use zlib off the thread pool, we can not report memory directly
+  // to V8; rather, we first store it as "unreported" memory in a separate
+  // field and later report it back from the main thread.
+  static void* AllocForZlib(void* data, uInt items, uInt size) {
+    ZCtx* ctx = static_cast<ZCtx*>(data);
+    size_t real_size =
+        MultiplyWithOverflowCheck(static_cast<size_t>(items),
+                                  static_cast<size_t>(size)) + sizeof(size_t);
+    char* memory = UncheckedMalloc(real_size);
+    if (UNLIKELY(memory == nullptr)) return nullptr;
+    *reinterpret_cast<size_t*>(memory) = real_size;
+    ctx->unreported_allocations_.fetch_add(real_size,
+                                           std::memory_order_relaxed);
+    return memory + sizeof(size_t);
+  }
+
+  static void FreeForZlib(void* data, void* pointer) {
+    if (UNLIKELY(pointer == nullptr)) return;
+    ZCtx* ctx = static_cast<ZCtx*>(data);
+    char* real_pointer = static_cast<char*>(pointer) - sizeof(size_t);
+    size_t real_size = *reinterpret_cast<size_t*>(real_pointer);
+    ctx->unreported_allocations_.fetch_sub(real_size,
+                                           std::memory_order_relaxed);
+    free(real_pointer);
+  }
+
+  // This is called on the main thread after zlib may have allocated something
+  // in order to report it back to V8.
+  void AdjustAmountOfExternalAllocatedMemory() {
+    ssize_t report =
+        unreported_allocations_.exchange(0, std::memory_order_relaxed);
+    if (report == 0) return;
+    CHECK_IMPLIES(report < 0, zlib_memory_ >= static_cast<size_t>(-report));
+    zlib_memory_ += report;
+    env()->isolate()->AdjustAmountOfExternalAllocatedMemory(report);
+  }
+
+  struct AllocScope {
+    explicit AllocScope(ZCtx* ctx) : ctx(ctx) {}
+    ~AllocScope() { ctx->AdjustAmountOfExternalAllocatedMemory(); }
+    ZCtx* ctx;
+  };
 
   Bytef* dictionary_;
   size_t dictionary_len_;
@@ -680,6 +729,8 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
   unsigned int gzip_id_bytes_read_;
   uint32_t* write_result_;
   Persistent<Function> write_js_callback_;
+  std::atomic<ssize_t> unreported_allocations_{0};
+  size_t zlib_memory_ = 0;
 };
 
 

From 122ae24f62de6f848eadcf72b75dff6114cf0079 Mon Sep 17 00:00:00 2001
From: "Steven R. Loomis" <srloomis@us.ibm.com>
Date: Mon, 9 Jul 2018 13:46:16 -0700
Subject: [PATCH 039/116] deps: icu 62.1 bump (Unicode 11, CLDR 33.1)

- Full release notes: http://site.icu-project.org/download/62

Fixes: https://github.com/nodejs/node/issues/21452
PR-URL: https://github.com/nodejs/node/pull/21728

Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Bradley Farias <bradley.meck@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
---
 configure                                     |    4 +-
 deps/icu-small/README-SMALL-ICU.txt           |    4 +-
 deps/icu-small/source/common/charstr.cpp      |   12 +
 deps/icu-small/source/common/charstr.h        |   12 +
 deps/icu-small/source/common/cmemory.h        |   45 +-
 deps/icu-small/source/common/edits.cpp        |   29 +-
 deps/icu-small/source/common/locmap.cpp       |    2 +-
 deps/icu-small/source/common/norm2_nfc_data.h | 1219 ++--
 deps/icu-small/source/common/propname_data.h  | 1744 ++---
 deps/icu-small/source/common/putil.cpp        |   22 +
 deps/icu-small/source/common/putilimp.h       |   26 +
 deps/icu-small/source/common/rbbi.cpp         |  112 +-
 deps/icu-small/source/common/rbbi_cache.cpp   |   49 +-
 deps/icu-small/source/common/rbbidata.cpp     |   41 -
 deps/icu-small/source/common/rbbidata.h       |    8 +-
 deps/icu-small/source/common/rbbirb.cpp       |  194 +-
 deps/icu-small/source/common/rbbirb.h         |   23 +-
 deps/icu-small/source/common/rbbiscan.cpp     |   18 +-
 deps/icu-small/source/common/rbbisetb.cpp     |   12 +-
 deps/icu-small/source/common/rbbisetb.h       |    8 +-
 deps/icu-small/source/common/rbbitblb.cpp     |  345 +-
 deps/icu-small/source/common/rbbitblb.h       |   77 +-
 deps/icu-small/source/common/serv.cpp         |    3 +-
 .../source/common/static_unicode_sets.cpp     |  222 +
 .../source/common/static_unicode_sets.h       |  119 +
 .../source/common/ubidi_props_data.h          | 1315 ++--
 deps/icu-small/source/common/ucase.cpp        |   53 +-
 deps/icu-small/source/common/ucase.h          |   18 +-
 .../source/common/ucase_props_data.h          | 1503 ++--
 .../source/common/uchar_props_data.h          | 6193 +++++++++--------
 deps/icu-small/source/common/ucln_cmn.h       |    1 +
 deps/icu-small/source/common/ucnv_bld.cpp     |   11 +-
 deps/icu-small/source/common/ucnv_bld.h       |    3 +
 deps/icu-small/source/common/ucurr.cpp        |  189 +-
 deps/icu-small/source/common/ucurrimp.h       |   17 +
 .../icu-small/source/common/unicode/brkiter.h |    2 +-
 .../source/common/unicode/bytestriebuilder.h  |    2 +-
 .../icu-small/source/common/unicode/caniter.h |    4 +-
 .../icu-small/source/common/unicode/docmain.h |    2 +-
 deps/icu-small/source/common/unicode/edits.h  |  150 +-
 .../source/common/unicode/platform.h          |   14 -
 deps/icu-small/source/common/unicode/rbbi.h   |   24 +-
 deps/icu-small/source/common/unicode/uchar.h  |   45 +-
 deps/icu-small/source/common/unicode/unistr.h |    6 +-
 .../icu-small/source/common/unicode/urename.h |   13 +
 .../icu-small/source/common/unicode/uscript.h |   17 +-
 deps/icu-small/source/common/unicode/utypes.h |    5 +-
 .../icu-small/source/common/unicode/uvernum.h |   10 +-
 deps/icu-small/source/common/uprops.cpp       |    1 +
 deps/icu-small/source/common/uprops.h         |    6 +-
 .../icu-small/source/common/uscript_props.cpp |    9 +-
 deps/icu-small/source/common/ustr_cnv.cpp     |    3 +-
 deps/icu-small/source/common/util.h           |    7 +
 deps/icu-small/source/common/utypes.cpp       |    3 +-
 deps/icu-small/source/common/wintz.cpp        |   28 +-
 .../data/in/{icudt61l.dat => icudt62l.dat}    |  Bin 2795984 -> 2808160 bytes
 .../source/i18n/affixpatternparser.cpp        |  698 --
 .../source/i18n/affixpatternparser.h          |  402 --
 deps/icu-small/source/i18n/collationfcd.cpp   |   98 +-
 .../source/i18n/compactdecimalformat.cpp      | 1018 +--
 deps/icu-small/source/i18n/currpinf.cpp       |    3 +
 deps/icu-small/source/i18n/currunit.cpp       |   33 +-
 deps/icu-small/source/i18n/dcfmtimp.h         |   54 -
 deps/icu-small/source/i18n/dcfmtsym.cpp       |   10 +-
 deps/icu-small/source/i18n/decfmtst.cpp       |  251 -
 deps/icu-small/source/i18n/decfmtst.h         |   69 -
 .../source/i18n/decimalformatpattern.cpp      |  656 --
 .../source/i18n/decimalformatpattern.h        |  106 -
 .../source/i18n/decimalformatpatternimpl.h    |   35 -
 deps/icu-small/source/i18n/decimfmt.cpp       | 4030 +++--------
 deps/icu-small/source/i18n/decimfmtimpl.cpp   | 1596 -----
 deps/icu-small/source/i18n/decimfmtimpl.h     |  549 --
 deps/icu-small/source/i18n/digitaffix.cpp     |  109 -
 deps/icu-small/source/i18n/digitaffix.h       |  104 -
 .../source/i18n/digitaffixesandpadding.cpp    |  175 -
 .../source/i18n/digitaffixesandpadding.h      |  179 -
 deps/icu-small/source/i18n/digitformatter.cpp |  417 --
 deps/icu-small/source/i18n/digitformatter.h   |  288 -
 deps/icu-small/source/i18n/digitgrouping.cpp  |   58 -
 deps/icu-small/source/i18n/digitgrouping.h    |  112 -
 deps/icu-small/source/i18n/digitinterval.cpp  |   55 -
 deps/icu-small/source/i18n/digitinterval.h    |  159 -
 deps/icu-small/source/i18n/digitlst.cpp       | 1143 ---
 deps/icu-small/source/i18n/digitlst.h         |  529 --
 .../source/i18n/double-conversion-strtod.cpp  |  574 ++
 .../source/i18n/double-conversion-strtod.h    |   63 +
 .../source/i18n/double-conversion-utils.h     |    4 +-
 .../source/i18n/double-conversion.cpp         |    7 +-
 .../icu-small/source/i18n/double-conversion.h |    2 +-
 deps/icu-small/source/i18n/fmtable.cpp        |  160 +-
 deps/icu-small/source/i18n/fmtableimp.h       |   12 +-
 deps/icu-small/source/i18n/fphdlimp.cpp       |   21 +-
 deps/icu-small/source/i18n/fphdlimp.h         |   23 +-
 deps/icu-small/source/i18n/measunit.cpp       |   87 +-
 deps/icu-small/source/i18n/msgfmt.cpp         |   32 +-
 deps/icu-small/source/i18n/nfsubs.cpp         |   25 +-
 .../source/i18n/number_affixutils.cpp         |   62 +-
 .../icu-small/source/i18n/number_affixutils.h |   65 +-
 .../icu-small/source/i18n/number_asformat.cpp |  105 +
 deps/icu-small/source/i18n/number_asformat.h  |  107 +
 deps/icu-small/source/i18n/number_capi.cpp    |  213 +
 deps/icu-small/source/i18n/number_compact.cpp |   15 +-
 deps/icu-small/source/i18n/number_compact.h   |    2 +-
 .../source/i18n/number_currencysymbols.cpp    |  123 +
 .../source/i18n/number_currencysymbols.h      |   65 +
 .../source/i18n/number_decimalquantity.cpp    |  414 +-
 .../source/i18n/number_decimalquantity.h      |   92 +-
 .../source/i18n/number_decimfmtprops.cpp      |   80 +-
 .../source/i18n/number_decimfmtprops.h        |   79 +-
 deps/icu-small/source/i18n/number_decnum.h    |   77 +
 deps/icu-small/source/i18n/number_fluent.cpp  |  625 +-
 .../source/i18n/number_formatimpl.cpp         |  262 +-
 .../icu-small/source/i18n/number_formatimpl.h |   33 +-
 .../icu-small/source/i18n/number_grouping.cpp |   33 +-
 .../source/i18n/number_integerwidth.cpp       |   28 +-
 .../source/i18n/number_longnames.cpp          |    7 +-
 deps/icu-small/source/i18n/number_longnames.h |    2 +-
 deps/icu-small/source/i18n/number_mapper.cpp  |  502 ++
 deps/icu-small/source/i18n/number_mapper.h    |  206 +
 .../icu-small/source/i18n/number_microprops.h |   82 +
 .../source/i18n/number_modifiers.cpp          |    6 +-
 deps/icu-small/source/i18n/number_modifiers.h |    2 +-
 .../source/i18n/number_multiplier.cpp         |  156 +
 .../icu-small/source/i18n/number_multiplier.h |   57 +
 .../icu-small/source/i18n/number_notation.cpp |   15 +-
 deps/icu-small/source/i18n/number_padding.cpp |   14 +-
 .../source/i18n/number_patternmodifier.cpp    |  243 +-
 .../source/i18n/number_patternmodifier.h      |   52 +-
 .../source/i18n/number_patternstring.cpp      |  323 +-
 .../source/i18n/number_patternstring.h        |  117 +-
 .../icu-small/source/i18n/number_rounding.cpp |  195 +-
 .../source/i18n/number_roundingutils.h        |   57 +-
 .../source/i18n/number_scientific.cpp         |   23 +-
 .../icu-small/source/i18n/number_scientific.h |    2 +-
 .../source/i18n/number_skeletons.cpp          | 1510 ++++
 deps/icu-small/source/i18n/number_skeletons.h |  327 +
 .../source/i18n/number_stringbuilder.cpp      |   59 +-
 .../source/i18n/number_stringbuilder.h        |   16 +-
 deps/icu-small/source/i18n/number_types.h     |   92 +-
 deps/icu-small/source/i18n/number_utils.cpp   |  253 +
 deps/icu-small/source/i18n/number_utils.h     |  144 +-
 deps/icu-small/source/i18n/number_utypes.h    |   79 +
 deps/icu-small/source/i18n/numfmt.cpp         |   92 +-
 .../source/i18n/numparse_affixes.cpp          |  470 ++
 deps/icu-small/source/i18n/numparse_affixes.h |  255 +
 .../source/i18n/numparse_compositions.cpp     |  107 +
 .../source/i18n/numparse_compositions.h       |  124 +
 .../source/i18n/numparse_currency.cpp         |  186 +
 .../icu-small/source/i18n/numparse_currency.h |   74 +
 .../source/i18n/numparse_decimal.cpp          |  458 ++
 deps/icu-small/source/i18n/numparse_decimal.h |   76 +
 deps/icu-small/source/i18n/numparse_impl.cpp  |  361 +
 deps/icu-small/source/i18n/numparse_impl.h    |  109 +
 .../source/i18n/numparse_parsednumber.cpp     |  122 +
 .../source/i18n/numparse_scientific.cpp       |  133 +
 .../source/i18n/numparse_scientific.h         |   45 +
 .../source/i18n/numparse_stringsegment.cpp    |  146 +
 .../source/i18n/numparse_stringsegment.h      |   24 +
 .../source/i18n/numparse_symbols.cpp          |  193 +
 deps/icu-small/source/i18n/numparse_symbols.h |  173 +
 deps/icu-small/source/i18n/numparse_types.h   |  377 +
 deps/icu-small/source/i18n/numparse_utils.h   |   43 +
 .../source/i18n/numparse_validators.cpp       |   85 +
 .../source/i18n/numparse_validators.h         |   95 +
 deps/icu-small/source/i18n/pluralaffix.cpp    |  104 -
 deps/icu-small/source/i18n/pluralaffix.h      |  177 -
 deps/icu-small/source/i18n/plurfmt.cpp        |   59 +-
 deps/icu-small/source/i18n/plurrule.cpp       |   63 +-
 deps/icu-small/source/i18n/plurrule_impl.h    |  135 +-
 deps/icu-small/source/i18n/precision.cpp      |  444 --
 deps/icu-small/source/i18n/precision.h        |  323 -
 .../source/i18n/quantityformatter.cpp         |   10 +-
 deps/icu-small/source/i18n/rbnf.cpp           |   54 +-
 deps/icu-small/source/i18n/reldatefmt.cpp     |    3 +-
 .../source/i18n/scientificnumberformatter.cpp |   17 +-
 .../source/i18n/significantdigitinterval.h    |   92 -
 .../source/i18n/smallintformatter.cpp         | 2622 -------
 .../icu-small/source/i18n/smallintformatter.h |   90 -
 deps/icu-small/source/i18n/smpdtfmt.cpp       |  356 +-
 deps/icu-small/source/i18n/timezone.cpp       |    5 +-
 deps/icu-small/source/i18n/ucln_in.h          |    1 +
 .../i18n/unicode/compactdecimalformat.h       |  267 +-
 deps/icu-small/source/i18n/unicode/currunit.h |    5 +-
 deps/icu-small/source/i18n/unicode/dcfmtsym.h |    9 +-
 deps/icu-small/source/i18n/unicode/decimfmt.h |  740 +-
 deps/icu-small/source/i18n/unicode/fmtable.h  |   35 +-
 deps/icu-small/source/i18n/unicode/fpositer.h |    8 -
 deps/icu-small/source/i18n/unicode/measunit.h |    8 -
 deps/icu-small/source/i18n/unicode/nounit.h   |   12 +-
 .../source/i18n/unicode/numberformatter.h     | 1558 +++--
 deps/icu-small/source/i18n/unicode/numfmt.h   |   18 +-
 deps/icu-small/source/i18n/unicode/plurrule.h |   21 -
 deps/icu-small/source/i18n/unicode/rbnf.h     |    4 +-
 .../i18n/unicode/scientificnumberformatter.h  |    5 -
 deps/icu-small/source/i18n/unicode/smpdtfmt.h |   39 +-
 deps/icu-small/source/i18n/unicode/timezone.h |    2 +
 deps/icu-small/source/i18n/unicode/unum.h     |   31 +-
 .../source/i18n/unicode/unumberformatter.h    |  666 ++
 deps/icu-small/source/i18n/unicode/uspoof.h   |   25 +-
 deps/icu-small/source/i18n/upluralrules.cpp   |   37 +-
 deps/icu-small/source/i18n/uspoof.cpp         |  193 +-
 deps/icu-small/source/i18n/uspoof_build.cpp   |   21 +
 deps/icu-small/source/i18n/uspoof_conf.cpp    |   37 +-
 deps/icu-small/source/i18n/uspoof_impl.cpp    |   50 +-
 deps/icu-small/source/i18n/uspoof_impl.h      |    3 +
 deps/icu-small/source/i18n/valueformatter.cpp |  223 -
 deps/icu-small/source/i18n/valueformatter.h   |  161 -
 deps/icu-small/source/i18n/visibledigits.cpp  |  186 -
 deps/icu-small/source/i18n/visibledigits.h    |  162 -
 deps/icu-small/source/i18n/windtfmt.cpp       |    3 +-
 deps/icu-small/source/i18n/zonemeta.cpp       |    1 +
 .../source/tools/toolutil/swapimpl.cpp        |    2 +-
 .../source/tools/toolutil/udbgutil.cpp        |    1 -
 213 files changed, 22043 insertions(+), 25764 deletions(-)
 create mode 100644 deps/icu-small/source/common/static_unicode_sets.cpp
 create mode 100644 deps/icu-small/source/common/static_unicode_sets.h
 rename deps/icu-small/source/data/in/{icudt61l.dat => icudt62l.dat} (65%)
 delete mode 100644 deps/icu-small/source/i18n/affixpatternparser.cpp
 delete mode 100644 deps/icu-small/source/i18n/affixpatternparser.h
 delete mode 100644 deps/icu-small/source/i18n/dcfmtimp.h
 delete mode 100644 deps/icu-small/source/i18n/decfmtst.cpp
 delete mode 100644 deps/icu-small/source/i18n/decfmtst.h
 delete mode 100644 deps/icu-small/source/i18n/decimalformatpattern.cpp
 delete mode 100644 deps/icu-small/source/i18n/decimalformatpattern.h
 delete mode 100644 deps/icu-small/source/i18n/decimalformatpatternimpl.h
 delete mode 100644 deps/icu-small/source/i18n/decimfmtimpl.cpp
 delete mode 100644 deps/icu-small/source/i18n/decimfmtimpl.h
 delete mode 100644 deps/icu-small/source/i18n/digitaffix.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitaffix.h
 delete mode 100644 deps/icu-small/source/i18n/digitaffixesandpadding.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitaffixesandpadding.h
 delete mode 100644 deps/icu-small/source/i18n/digitformatter.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitformatter.h
 delete mode 100644 deps/icu-small/source/i18n/digitgrouping.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitgrouping.h
 delete mode 100644 deps/icu-small/source/i18n/digitinterval.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitinterval.h
 delete mode 100644 deps/icu-small/source/i18n/digitlst.cpp
 delete mode 100644 deps/icu-small/source/i18n/digitlst.h
 create mode 100644 deps/icu-small/source/i18n/double-conversion-strtod.cpp
 create mode 100644 deps/icu-small/source/i18n/double-conversion-strtod.h
 create mode 100644 deps/icu-small/source/i18n/number_asformat.cpp
 create mode 100644 deps/icu-small/source/i18n/number_asformat.h
 create mode 100644 deps/icu-small/source/i18n/number_capi.cpp
 create mode 100644 deps/icu-small/source/i18n/number_currencysymbols.cpp
 create mode 100644 deps/icu-small/source/i18n/number_currencysymbols.h
 create mode 100644 deps/icu-small/source/i18n/number_decnum.h
 create mode 100644 deps/icu-small/source/i18n/number_mapper.cpp
 create mode 100644 deps/icu-small/source/i18n/number_mapper.h
 create mode 100644 deps/icu-small/source/i18n/number_microprops.h
 create mode 100644 deps/icu-small/source/i18n/number_multiplier.cpp
 create mode 100644 deps/icu-small/source/i18n/number_multiplier.h
 create mode 100644 deps/icu-small/source/i18n/number_skeletons.cpp
 create mode 100644 deps/icu-small/source/i18n/number_skeletons.h
 create mode 100644 deps/icu-small/source/i18n/number_utils.cpp
 create mode 100644 deps/icu-small/source/i18n/number_utypes.h
 create mode 100644 deps/icu-small/source/i18n/numparse_affixes.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_affixes.h
 create mode 100644 deps/icu-small/source/i18n/numparse_compositions.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_compositions.h
 create mode 100644 deps/icu-small/source/i18n/numparse_currency.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_currency.h
 create mode 100644 deps/icu-small/source/i18n/numparse_decimal.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_decimal.h
 create mode 100644 deps/icu-small/source/i18n/numparse_impl.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_impl.h
 create mode 100644 deps/icu-small/source/i18n/numparse_parsednumber.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_scientific.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_scientific.h
 create mode 100644 deps/icu-small/source/i18n/numparse_stringsegment.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_stringsegment.h
 create mode 100644 deps/icu-small/source/i18n/numparse_symbols.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_symbols.h
 create mode 100644 deps/icu-small/source/i18n/numparse_types.h
 create mode 100644 deps/icu-small/source/i18n/numparse_utils.h
 create mode 100644 deps/icu-small/source/i18n/numparse_validators.cpp
 create mode 100644 deps/icu-small/source/i18n/numparse_validators.h
 delete mode 100644 deps/icu-small/source/i18n/pluralaffix.cpp
 delete mode 100644 deps/icu-small/source/i18n/pluralaffix.h
 delete mode 100644 deps/icu-small/source/i18n/precision.cpp
 delete mode 100644 deps/icu-small/source/i18n/precision.h
 delete mode 100644 deps/icu-small/source/i18n/significantdigitinterval.h
 delete mode 100644 deps/icu-small/source/i18n/smallintformatter.cpp
 delete mode 100644 deps/icu-small/source/i18n/smallintformatter.h
 create mode 100644 deps/icu-small/source/i18n/unicode/unumberformatter.h
 delete mode 100644 deps/icu-small/source/i18n/valueformatter.cpp
 delete mode 100644 deps/icu-small/source/i18n/valueformatter.h
 delete mode 100644 deps/icu-small/source/i18n/visibledigits.cpp
 delete mode 100644 deps/icu-small/source/i18n/visibledigits.h

diff --git a/configure b/configure
index 3a9ab42414569e..094d8e09f745d9 100755
--- a/configure
+++ b/configure
@@ -1185,8 +1185,8 @@ def glob_to_var(dir_base, dir_sub, patch_dir):
 def configure_intl(o):
   icus = [
     {
-      'url': 'https://ssl.icu-project.org/files/icu4c/61.1/icu4c-61_1-src.zip',
-      'md5': '780d8524c8a860ed8d8f6fe75cb7ce3f',
+      'url': 'https://sourceforge.net/projects/icu/files/ICU4C/62.1/icu4c-62_1-src.zip',
+      'md5': '408854f7b9b58311b68fab4b4dfc80be',
     },
   ]
   def icu_download(path):
diff --git a/deps/icu-small/README-SMALL-ICU.txt b/deps/icu-small/README-SMALL-ICU.txt
index b3919ec52b21ae..b98a528485653b 100644
--- a/deps/icu-small/README-SMALL-ICU.txt
+++ b/deps/icu-small/README-SMALL-ICU.txt
@@ -1,8 +1,8 @@
 Small ICU sources - auto generated by shrink-icu-src.py
 
 This directory contains the ICU subset used by --with-intl=small-icu (the default)
-It is a strict subset of ICU 61 source files with the following exception(s):
-* deps/icu-small/source/data/in/icudt61l.dat : Reduced-size data file
+It is a strict subset of ICU 62 source files with the following exception(s):
+* deps/icu-small/source/data/in/icudt62l.dat : Reduced-size data file
 
 
 To rebuild this directory, see ../../tools/icu/README.md
diff --git a/deps/icu-small/source/common/charstr.cpp b/deps/icu-small/source/common/charstr.cpp
index 8bacd20ddc7a68..353f1d52542fa2 100644
--- a/deps/icu-small/source/common/charstr.cpp
+++ b/deps/icu-small/source/common/charstr.cpp
@@ -23,6 +23,18 @@
 
 U_NAMESPACE_BEGIN
 
+CharString::CharString(CharString&& src) U_NOEXCEPT
+        : buffer(std::move(src.buffer)), len(src.len) {
+    src.len = 0;  // not strictly necessary because we make no guarantees on the source string
+}
+
+CharString& CharString::operator=(CharString&& src) U_NOEXCEPT {
+    buffer = std::move(src.buffer);
+    len = src.len;
+    src.len = 0;  // not strictly necessary because we make no guarantees on the source string
+    return *this;
+}
+
 CharString &CharString::copyFrom(const CharString &s, UErrorCode &errorCode) {
     if(U_SUCCESS(errorCode) && this!=&s && ensureCapacity(s.len+1, 0, errorCode)) {
         len=s.len;
diff --git a/deps/icu-small/source/common/charstr.h b/deps/icu-small/source/common/charstr.h
index 3cfdf6a897a497..86f69c383a0b37 100644
--- a/deps/icu-small/source/common/charstr.h
+++ b/deps/icu-small/source/common/charstr.h
@@ -55,6 +55,18 @@ class U_COMMON_API CharString : public UMemory {
     }
     ~CharString() {}
 
+    /**
+     * Move constructor; might leave src in an undefined state.
+     * This string will have the same contents and state that the source string had.
+     */
+    CharString(CharString &&src) U_NOEXCEPT;
+    /**
+     * Move assignment operator; might leave src in an undefined state.
+     * This string will have the same contents and state that the source string had.
+     * The behavior is undefined if *this and src are the same object.
+     */
+    CharString &operator=(CharString &&src) U_NOEXCEPT;
+
     /**
      * Replaces this string's contents with the other string's contents.
      * CharString does not support the standard copy constructor nor
diff --git a/deps/icu-small/source/common/cmemory.h b/deps/icu-small/source/common/cmemory.h
index a44f9a190293bd..f98e13efc0ffbe 100644
--- a/deps/icu-small/source/common/cmemory.h
+++ b/deps/icu-small/source/common/cmemory.h
@@ -299,6 +299,14 @@ class MaybeStackArray {
      * Destructor deletes the array (if owned).
      */
     ~MaybeStackArray() { releaseArray(); }
+    /**
+     * Move constructor: transfers ownership or copies the stack array.
+     */
+    MaybeStackArray(MaybeStackArray<T, stackCapacity> &&src) U_NOEXCEPT;
+    /**
+     * Move assignment: transfers ownership or copies the stack array.
+     */
+    MaybeStackArray<T, stackCapacity> &operator=(MaybeStackArray<T, stackCapacity> &&src) U_NOEXCEPT;
     /**
      * Returns the array capacity (number of T items).
      * @return array capacity
@@ -376,6 +384,11 @@ class MaybeStackArray {
             uprv_free(ptr);
         }
     }
+    void resetToStackArray() {
+        ptr=stackArray;
+        capacity=stackCapacity;
+        needToRelease=FALSE;
+    }
     /* No comparison operators with other MaybeStackArray's. */
     bool operator==(const MaybeStackArray & /*other*/) {return FALSE;}
     bool operator!=(const MaybeStackArray & /*other*/) {return TRUE;}
@@ -398,6 +411,34 @@ class MaybeStackArray {
 #endif
 };
 
+template<typename T, int32_t stackCapacity>
+icu::MaybeStackArray<T, stackCapacity>::MaybeStackArray(
+        MaybeStackArray <T, stackCapacity>&& src) U_NOEXCEPT
+        : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) {
+    if (src.ptr == src.stackArray) {
+        ptr = stackArray;
+        uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity);
+    } else {
+        src.resetToStackArray();  // take ownership away from src
+    }
+}
+
+template<typename T, int32_t stackCapacity>
+inline MaybeStackArray <T, stackCapacity>&
+MaybeStackArray<T, stackCapacity>::operator=(MaybeStackArray <T, stackCapacity>&& src) U_NOEXCEPT {
+    releaseArray();  // in case this instance had its own memory allocated
+    capacity = src.capacity;
+    needToRelease = src.needToRelease;
+    if (src.ptr == src.stackArray) {
+        ptr = stackArray;
+        uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity);
+    } else {
+        ptr = src.ptr;
+        src.resetToStackArray();  // take ownership away from src
+    }
+    return *this;
+}
+
 template<typename T, int32_t stackCapacity>
 inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t length) {
     if(newCapacity>0) {
@@ -447,9 +488,7 @@ inline T *MaybeStackArray<T, stackCapacity>::orphanOrClone(int32_t length, int32
         uprv_memcpy(p, ptr, (size_t)length*sizeof(T));
     }
     resultCapacity=length;
-    ptr=stackArray;
-    capacity=stackCapacity;
-    needToRelease=FALSE;
+    resetToStackArray();
     return p;
 }
 
diff --git a/deps/icu-small/source/common/edits.cpp b/deps/icu-small/source/common/edits.cpp
index 9ec005624fef0c..3b3611fcf80cfe 100644
--- a/deps/icu-small/source/common/edits.cpp
+++ b/deps/icu-small/source/common/edits.cpp
@@ -4,10 +4,12 @@
 // edits.cpp
 // created: 2017feb08 Markus W. Scherer
 
-#include "unicode/utypes.h"
 #include "unicode/edits.h"
+#include "unicode/unistr.h"
+#include "unicode/utypes.h"
 #include "cmemory.h"
 #include "uassert.h"
+#include "util.h"
 
 U_NAMESPACE_BEGIN
 
@@ -773,4 +775,29 @@ int32_t Edits::Iterator::sourceIndexFromDestinationIndex(int32_t i, UErrorCode &
     }
 }
 
+UnicodeString& Edits::Iterator::toString(UnicodeString& sb) const {
+    sb.append(u"{ src[", -1);
+    ICU_Utility::appendNumber(sb, srcIndex);
+    sb.append(u"..", -1);
+    ICU_Utility::appendNumber(sb, srcIndex + oldLength_);
+    if (changed) {
+        sb.append(u"] ⇝ dest[", -1);
+    } else {
+        sb.append(u"] ≡ dest[", -1);
+    }
+    ICU_Utility::appendNumber(sb, destIndex);
+    sb.append(u"..", -1);
+    ICU_Utility::appendNumber(sb, destIndex + newLength_);
+    if (changed) {
+        sb.append(u"], repl[", -1);
+        ICU_Utility::appendNumber(sb, replIndex);
+        sb.append(u"..", -1);
+        ICU_Utility::appendNumber(sb, replIndex + newLength_);
+        sb.append(u"] }", -1);
+    } else {
+        sb.append(u"] (no-change) }", -1);
+    }
+    return sb;
+}
+
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/locmap.cpp b/deps/icu-small/source/common/locmap.cpp
index 029c1edf032a00..a3cf2d5eb2dbcb 100644
--- a/deps/icu-small/source/common/locmap.cpp
+++ b/deps/icu-small/source/common/locmap.cpp
@@ -1015,7 +1015,7 @@ static const char*
 getPosixID(const ILcidPosixMap *this_0, uint32_t hostID)
 {
     uint32_t i;
-    for (i = 0; i <= this_0->numRegions; i++)
+    for (i = 0; i < this_0->numRegions; i++)
     {
         if (this_0->regionMaps[i].hostID == hostID)
         {
diff --git a/deps/icu-small/source/common/norm2_nfc_data.h b/deps/icu-small/source/common/norm2_nfc_data.h
index 8f5c4346db5ffe..c8bf440ae10819 100644
--- a/deps/icu-small/source/common/norm2_nfc_data.h
+++ b/deps/icu-small/source/common/norm2_nfc_data.h
@@ -12,625 +12,638 @@
 #ifdef INCLUDED_FROM_NORMALIZER2_CPP
 
 static const UVersionInfo norm2_nfc_data_formatVersion={3,0,0,0};
-static const UVersionInfo norm2_nfc_data_dataVersion={0xa,0,0,0};
+static const UVersionInfo norm2_nfc_data_dataVersion={0xb,0,0,0};
 
 static const int32_t norm2_nfc_data_indexes[Normalizer2Impl::IX_COUNT]={
-0x50,0x4cc0,0x8918,0x8a18,0x8a18,0x8a18,0x8a18,0x8a18,0xc0,0x300,0xadc,0x29d0,0x3c56,0xfc00,0x1282,0x3b8c,
+0x50,0x4e50,0x8aa8,0x8ba8,0x8ba8,0x8ba8,0x8ba8,0x8ba8,0xc0,0x300,0xadc,0x29d0,0x3c56,0xfc00,0x1282,0x3b8c,
 0x3c24,0x3c56,0x300,0
 };
 
-static const uint16_t norm2_nfc_data_trieIndex[9776]={
-0x2a8,0x2b0,0x2b8,0x2c0,0x2ce,0x2d6,0x2de,0x2e6,0x2ee,0x2f6,0x2fe,0x306,0x30e,0x316,0x31c,0x324,
-0x32c,0x334,0x2c7,0x2cf,0x339,0x341,0x2c7,0x2cf,0x349,0x351,0x359,0x361,0x369,0x371,0x379,0x381,
-0x389,0x391,0x399,0x3a1,0x3a9,0x3b1,0x3b9,0x3c1,0x2c7,0x2cf,0x2c7,0x2cf,0x3c8,0x3d0,0x3d8,0x3e0,
-0x3e4,0x3ec,0x3f2,0x3fa,0x2c7,0x2cf,0x402,0x40a,0x40e,0x416,0x41e,0x426,0x2c7,0x2cf,0x424,0x42c,
-0x431,0x438,0x43c,0x2c7,0x2c7,0x2c7,0x443,0x44b,0x2c7,0x453,0x45b,0x2c7,0x2c7,0x463,0x46b,0x2c7,
-0x2c7,0x473,0x47b,0x2c7,0x2c7,0x483,0x48b,0x2c7,0x2c7,0x463,0x492,0x2c7,0x49a,0x4a0,0x4a8,0x2c7,
-0x2c7,0x2c7,0x4af,0x2c7,0x2c7,0x4b5,0x4bd,0x2c7,0x2c7,0x4c3,0x4cb,0x2c7,0x2c7,0x2c7,0x4d1,0x2c7,
-0x2c7,0x4d9,0x4e0,0x2c7,0x2c7,0x4e3,0x4ea,0x2c7,0x4ed,0x4f4,0x4fc,0x504,0x50c,0x514,0x51b,0x2c7,
-0x2c7,0x522,0x2c7,0x2c7,0x529,0x2c7,0x2c7,0x2c7,0x93b,0x2c7,0x2c7,0x943,0x2c7,0x949,0x951,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x52d,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x535,0x535,0x2c7,0x2c7,0x2c7,0x2c7,0x53b,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x543,0x2c7,0x2c7,0x2c7,0x546,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x54d,0x2c7,0x2c7,0x555,0x2c7,0x55d,0x2c7,0x2c7,0x565,0x56a,0x572,0x578,0x2c7,0x57e,0x2c7,0x585,
-0x2c7,0x58a,0x2c7,0x2c7,0x2c7,0x2c7,0x590,0x598,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x5a0,0x5a5,
-0x5ad,0x5b5,0x5bd,0x5c5,0x5cd,0x5d5,0x5dd,0x5e5,0x5ed,0x5f5,0x5fd,0x605,0x60d,0x615,0x61d,0x625,
-0x62d,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x631,0x639,0x2c7,0x640,0x2c7,0x2c7,0x644,0x64b,0x650,0x2c7,
-0x658,0x660,0x668,0x670,0x678,0x680,0x2c7,0x688,0x2c7,0x68e,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x691,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x699,0x2c7,0x2c7,0x2c7,0x69e,0x2c7,0x2c7,0x2c7,0x6a6,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x6ae,0x6b5,0x6bd,0x6c5,0x6cd,0x6d5,0x6dd,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x6e5,0x6ed,0x2c7,0x2c7,0x6f5,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x6fc,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x703,0x70b,0x2c7,0x711,0x715,0x2c7,0x2c7,0x58b,0x71d,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x721,0x729,0x72c,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x48b,
-0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
-0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
-0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
-0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
-0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
-0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
-0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
-0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
-0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
-0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
-0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
-0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
-0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
-0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
-0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,
-0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,
-0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,
-0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,
-0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,
-0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,
-0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,
-0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x96d,0x959,0x95a,0x95b,0x95c,0x95d,0x95e,0x965,0x2c7,0x2c7,
-0x975,0x97c,0x2a8,0x983,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,
-0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,0x2a8,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x734,0x73c,0x744,0x74c,0x754,0x75c,0x764,0x76c,
-0x774,0x77c,0x784,0x78c,0x794,0x79c,0x7a4,0x2c7,0x7ab,0x7b3,0x7bb,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x7c3,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0xb20,0xb20,0xb38,0xb78,0xbb8,0xbf8,0xc38,0xc70,0xcb0,0xb1c,0xce4,0xb1c,0xd24,0xd64,0xda4,0xde4,
-0xe24,0xe64,0xea4,0xee4,0xb1c,0xb1c,0xf20,0xf60,0xf90,0xfc8,0xb1c,0x1008,0x1038,0x1078,0xb1c,0x1090,
-0x880,0x8b0,0x8ee,0x928,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x953,0x188,0x188,
-0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x96f,0x188,0x188,0x9a5,0x188,0x9e5,0xa1f,0x188,0x188,
+static const uint16_t norm2_nfc_data_trieIndex[9976]={
+0x2aa,0x2b2,0x2ba,0x2c2,0x2d0,0x2d8,0x2e0,0x2e8,0x2f0,0x2f8,0x300,0x308,0x310,0x318,0x31e,0x326,
+0x32e,0x336,0x2c9,0x2d1,0x33b,0x343,0x2c9,0x2d1,0x34b,0x353,0x35b,0x363,0x36b,0x373,0x37b,0x383,
+0x38b,0x393,0x39b,0x3a3,0x3ab,0x3b3,0x3bb,0x3c3,0x2c9,0x2d1,0x2c9,0x2d1,0x3ca,0x3d2,0x3da,0x3e2,
+0x3e6,0x3ee,0x3f4,0x3fc,0x2c9,0x2d1,0x404,0x40c,0x410,0x418,0x420,0x428,0x2c9,0x2d1,0x426,0x42e,
+0x436,0x43d,0x441,0x2c9,0x2c9,0x2c9,0x448,0x450,0x2c9,0x458,0x460,0x2c9,0x2c9,0x468,0x470,0x478,
+0x2c9,0x480,0x488,0x2c9,0x2c9,0x490,0x498,0x2c9,0x2c9,0x468,0x49f,0x2c9,0x4a7,0x4ad,0x4b5,0x2c9,
+0x2c9,0x2c9,0x4bc,0x2c9,0x2c9,0x4c2,0x4ca,0x2c9,0x2c9,0x4d0,0x4d8,0x2c9,0x2c9,0x2c9,0x4de,0x2c9,
+0x2c9,0x4e6,0x4ed,0x2c9,0x2c9,0x4f0,0x4f7,0x2c9,0x4fa,0x501,0x509,0x511,0x519,0x521,0x528,0x2c9,
+0x2c9,0x52f,0x2c9,0x2c9,0x536,0x2c9,0x2c9,0x2c9,0x96d,0x2c9,0x2c9,0x975,0x2c9,0x97b,0x983,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x53a,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x542,0x542,0x2c9,0x2c9,0x2c9,0x2c9,0x548,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x550,0x2c9,0x2c9,0x2c9,0x553,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x55a,0x2c9,0x2c9,0x562,0x2c9,0x56a,0x2c9,0x2c9,0x572,0x577,0x57f,0x585,0x2c9,0x58b,0x2c9,0x592,
+0x2c9,0x597,0x2c9,0x2c9,0x2c9,0x2c9,0x59d,0x5a5,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x5ad,0x5b2,
+0x5ba,0x5c2,0x5ca,0x5d2,0x5da,0x5e2,0x5ea,0x5f2,0x5fa,0x602,0x60a,0x612,0x61a,0x622,0x62a,0x632,
+0x63a,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x63e,0x646,0x2c9,0x64d,0x2c9,0x2c9,0x651,0x658,0x65d,0x2c9,
+0x665,0x66d,0x675,0x67d,0x685,0x68d,0x2c9,0x695,0x2c9,0x69b,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x69e,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x6a6,0x2c9,0x2c9,0x2c9,0x6ab,0x2c9,0x2c9,0x2c9,0x6b3,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x6bb,0x6c2,0x6ca,0x6d2,0x6da,0x6e2,0x6ea,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x6f2,0x6fa,0x2c9,0x2c9,0x702,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x709,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x710,0x718,0x2c9,0x71e,0x722,0x2c9,0x2c9,0x598,0x72a,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x72e,0x736,0x739,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x498,
+0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,
+0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,
+0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,
+0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,
+0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,
+0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,
+0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,
+0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,
+0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,
+0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,
+0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,
+0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,
+0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,
+0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,
+0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,
+0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,
+0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,
+0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,
+0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,
+0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,
+0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,
+0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x99f,0x98b,0x98c,0x98d,0x98e,0x98f,0x990,0x997,0x2c9,0x2c9,
+0x9a7,0x9ae,0x2aa,0x9b5,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,
+0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,0x2aa,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x741,0x749,0x751,0x759,0x761,0x769,0x771,0x779,
+0x781,0x789,0x791,0x799,0x7a1,0x7a9,0x7b1,0x2c9,0x7b8,0x7c0,0x7c8,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x7d0,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0xb28,0xb28,0xb40,0xb80,0xbc0,0xc00,0xc40,0xc78,0xcb8,0xb24,0xcec,0xb24,0xd2c,0xd6c,0xdac,0xdec,
+0xe2c,0xe6c,0xeac,0xeec,0xb24,0xb24,0xf28,0xf68,0xf98,0xfd0,0xb24,0x1010,0x1040,0x1080,0xb24,0x1098,
+0x880,0x8b0,0x8ee,0x92d,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x95a,0x188,0x188,
+0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x976,0x188,0x188,0x9ac,0x188,0x9ec,0xa26,0x188,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
-0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xa5f,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x7c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x7cf,0x2c7,0x2c7,0x2c7,0x7d2,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x7d9,0x7dd,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x7e5,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x6fc,0x69e,0x7e7,0x7ef,0x2c7,0x2c7,0x7f7,0x7fe,0x2c7,0x58b,0x2c7,0x2c7,0x806,0x2c7,0x2c7,0x809,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x80f,0x2c7,0x463,0x816,0x81d,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x825,0x2c7,0x2c7,0x829,0x831,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x836,0x83e,0x2c7,0x2c7,0x69e,
-0x2c7,0x2c7,0x2c7,0x841,0x2c7,0x2c7,0x2c7,0x847,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x535,0x848,0x2c7,0x84a,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x69e,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x852,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x856,0x2c7,0x85c,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x862,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x86a,
-0x872,0x87a,0x880,0x888,0x2c7,0x2c7,0x2c7,0x890,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x898,0x8a0,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x8a4,0x2c7,0x2c7,0x2c7,0x8ab,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x8b3,
-0x8bb,0x8c3,0x8cb,0x8d3,0x8db,0x8e3,0x8eb,0x8f3,0x8fb,0x903,0x90b,0x913,0x91b,0x923,0x92b,0x933,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,
-0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2c7,0x2a7,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,4,8,0xc,1,
-1,0x10,0x50,0x5c,0x70,0x88,0xcc,0xd0,0xec,0x108,0x144,0x148,0x15c,0x174,0x180,0x1a4,
-0x1e4,1,0x1ec,0x20c,0x228,0x244,0x290,0x298,0x2b0,0x2b8,0x2dc,1,1,1,1,1,
-1,0x2f4,0x334,0x340,0x354,0x36c,0x3b0,0x3b4,0x3d0,0x3f0,0x428,0x430,0x444,0x45c,0x468,0x48c,
-0x4cc,1,0x4d4,0x4f4,0x510,0x530,0x57c,0x584,0x5a0,0x5a8,0x5d0,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0x5e8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0x1284,0x128a,0xade,0x1290,0xaf4,0xafe,0x5f4,0xb08,
-0x1296,0x129c,0xb12,0x12a2,0x12a8,0x12ae,0x12b4,0xb28,1,0x12ba,0x12c0,0x12c6,0xb32,0xb48,0xb5a,1,
-0x5fc,0x12cc,0x12d2,0x12d8,0xb64,0x12de,1,1,0x12e4,0x12ea,0xb7a,0x12f0,0xb90,0xb9a,0x600,0xba4,
-0x12f6,0x12fc,0xbae,0x1302,0x1308,0x130e,0x1314,0xbc4,1,0x131a,0x1320,0x1326,0xbce,0xbe4,0xbf6,1,
-0x608,0x132c,0x1332,0x1338,0xc00,0x133e,1,0x1344,0x134a,0x1350,0xc16,0xc2c,0x1357,0x135d,0x1362,0x1368,
-0x136e,0x1374,0x137a,0x1380,0x1386,0x138c,0x1392,0x1398,1,1,0xc42,0xc50,0x139e,0x13a4,0x13aa,0x13b0,
-0x13b7,0x13bd,0x13c2,0x13c8,0x13ce,0x13d4,0x13da,0x13e0,0x13e6,0x13ec,0x13f3,0x13f9,0x13fe,0x1404,1,1,
-0x140a,0x1410,0x1416,0x141c,0x1422,0x1428,0x142f,0x1435,0x143a,1,1,1,0x1441,0x1447,0x144d,0x1453,
-1,0x1458,0x145e,0x1465,0x146b,0x1470,0x1476,1,1,1,1,0x147c,0x1482,0x1489,0x148f,0x1494,
-0x149a,1,1,1,0xc5e,0xc6c,0x14a0,0x14a6,0x14ac,0x14b2,1,1,0x14b8,0x14be,0x14c5,0x14cb,
-0x14d0,0x14d6,0xc7a,0xc84,0x14dc,0x14e2,0x14e9,0x14ef,0xc8e,0xc98,0x14f5,0x14fb,0x1500,0x1506,1,1,
-0xca2,0xcac,0xcb6,0xcc0,0x150c,0x1512,0x1518,0x151e,0x1524,0x152a,0x1531,0x1537,0x153c,0x1542,0x1548,0x154e,
-0x1554,0x155a,0x1560,0x1566,0x156c,0x1572,0x1578,0x60c,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xcca,0xce4,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xcfe,0xd18,1,1,1,1,1,1,0x610,
-1,1,1,1,1,1,1,1,1,1,1,1,1,0x157e,0x1584,0x158a,
-0x1590,0x1596,0x159c,0x15a2,0x15a8,0x15b0,0x15ba,0x15c4,0x15ce,0x15d8,0x15e2,0x15ec,0x15f6,1,0x1600,0x160a,
-0x1614,0x161e,0x1627,0x162d,1,1,0x1632,0x1638,0x163e,0x1644,0xd32,0xd3c,0x164d,0x1657,0x165f,0x1665,
-0x166b,1,1,1,0x1670,0x1676,1,1,0x167c,0x1682,0x168a,0x1694,0x169d,0x16a3,0x16a9,0x16af,
-0x16b4,0x16ba,0x16c0,0x16c6,0x16cc,0x16d2,0x16d8,0x16de,0x16e4,0x16ea,0x16f0,0x16f6,0x16fc,0x1702,0x1708,0x170e,
-0x1714,0x171a,0x1720,0x1726,0x172c,0x1732,0x1738,0x173e,0x1744,0x174a,0x1750,0x1756,1,1,0x175c,0x1762,
-1,1,1,1,1,1,0xd46,0xd50,0xd5a,0xd64,0x176a,0x1774,0x177e,0x1788,0xd6e,0xd78,
-0x1792,0x179c,0x17a4,0x17aa,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0x614,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xffcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,
-0xfdcc,0xffcc,0xffcc,0xfdcc,0xffcc,0xfdcc,0xffcc,0xfdcc,0xfdcc,0xffd0,0xffb8,0xffb8,0xffb8,0xffb8,0xffd0,0xfdb0,
-0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xff94,0xff94,0xfdb8,0xfdb8,0xfdb8,0xfdb8,0xfd94,0xfd94,0xffb8,0xffb8,0xffb8,
-0xffb8,0xfdb8,0xfdb8,0xffb8,0xfdb8,0xfdb8,0xffb8,0xffb8,0xfe02,0xfe02,0xfe02,0xfe02,0xfc02,0xffb8,0xffb8,0xffb8,
-0xffb8,0xffcc,0xffcc,0xffcc,0x3c26,0x3c2c,0xfdcc,0x3c32,0x3c38,0xfde0,0xffcc,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,
-0xffcc,0xffb8,0xffb8,1,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffd0,0xffb8,0xffb8,0xffcc,
-0xffd2,0xffd4,0xffd4,0xffd2,0xffd4,0xffd4,0xffd2,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,0x29d1,1,1,1,1,1,1,1,
-1,1,0x29d5,1,1,1,1,1,1,0x17b1,0x17b7,0x29d9,0x17bd,0x17c3,0x17c9,1,
-0x17cf,1,0x17d5,0x17db,0x17e3,0x618,1,1,1,0x634,1,0x644,1,0x658,1,1,
-1,1,1,0x674,1,0x684,1,1,1,0x688,1,1,1,0x6a0,0x17eb,0x17f1,
-0xd82,0x17f7,0xd8c,0x17fd,0x1805,0x6b4,1,1,1,0x6d4,1,0x6e4,1,0x6fc,1,1,
-1,1,1,0x71c,1,0x72c,1,1,1,0x734,1,1,1,0x754,0xd96,0xda8,
-0x180d,0x1813,0xdba,1,1,1,0x76c,0x1819,0x181f,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0x1825,0x182b,1,0x1831,1,1,0x774,0x1837,1,1,1,1,
-0x183d,0x1843,0x1849,1,0x778,1,1,0x780,1,0x784,0x790,0x798,0x79c,0x184f,0x7ac,1,
-1,1,0x7b0,1,1,1,1,0x7b4,1,1,1,0x7c4,1,1,1,0x7c8,
-1,0x7cc,1,1,0x7d0,1,1,0x7d8,1,0x7dc,0x7e8,0x7f0,0x7f4,0x1855,0x804,1,
-1,1,0x808,1,1,1,1,0x80c,1,1,1,0x81c,1,1,1,0x820,
-1,0x824,1,1,0x185b,0x1861,1,0x1867,1,1,0x828,0x186d,1,1,1,1,
-0x1873,0x1879,0x187f,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0x82c,0x830,0x1885,0x188b,1,1,1,1,
-1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,0x1891,0x1897,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0x189d,0x18a3,0x18a9,0x18af,1,1,0x18b5,0x18bb,0x834,0x838,0x18c1,0x18c7,
-0x18cd,0x18d3,0x18d9,0x18df,1,1,0x18e5,0x18eb,0x18f1,0x18f7,0x18fd,0x1903,0x83c,0x840,0x1909,0x190f,
-0x1915,0x191b,0x1921,0x1927,0x192d,0x1933,0x1939,0x193f,0x1945,0x194b,1,1,0x1951,0x1957,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffbc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffbc,0xffc8,0xffcc,
-0xfe14,0xfe16,0xfe18,0xfe1a,0xfe1c,0xfe1e,0xfe20,0xfe22,0xfe24,0xfe26,0xfe26,0xfe28,0xfe2a,0xfe2c,1,0xfe2e,
-1,0xfe30,0xfe32,1,0xffcc,0xffb8,1,0xfe24,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xfe3c,0xfe3e,0xfe40,1,1,1,1,1,
-1,1,0x195c,0x1962,0x1969,0x196f,0x1975,0x844,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0x850,1,0x854,0xfe36,0xfe38,0xfe3a,0xfe3c,0xfe3e,0xfe40,0xfe42,0xfe44,0xfdcc,0xfdcc,0xfdb8,0xffb8,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xfe46,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0x197b,0x858,0x1981,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x85c,0x1987,1,0x860,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,1,1,0xffcc,
-0xffcc,1,0xffb8,0xffcc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xfe48,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,
-0xffb8,0xffb8,0xffcc,0xffb8,0xffb8,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,
-0xffb8,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffb8,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xffb8,0xffb8,0xffb8,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffb8,
-0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xfe36,0xfe38,0xfe3a,0xffcc,
-0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
-1,1,1,1,0x864,0x198d,1,1,1,1,1,1,0x868,0x1993,1,0x86c,
-0x1999,1,1,1,1,1,1,1,0xfc0e,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,0xffcc,0xffb8,0xffcc,
-0xffcc,1,1,1,0x29dc,0x29e2,0x29e8,0x29ee,0x29f4,0x29fa,0x2a00,0x2a06,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xfe0e,1,0xfc00,1,1,1,1,1,
-1,1,1,0x870,1,1,1,0x199f,0x19a5,0xfe12,1,1,1,1,1,1,
-1,1,1,0xfc00,1,1,1,1,0x2a0c,0x2a12,1,0x2a18,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x2a1e,
-1,1,0x2a24,1,1,1,1,1,0xfe0e,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,
-1,1,1,1,1,0x2a2a,0x2a30,0x2a36,1,1,0x2a3c,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xfe0e,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x878,
-0x19ab,1,1,0x19b1,0x19b7,0xfe12,1,1,1,1,1,1,1,1,0xfc00,0xfc00,
-1,1,1,1,0x2a42,0x2a48,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x884,1,0x19bd,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,1,
-1,1,1,1,1,1,0x888,0x890,1,1,0x19c3,0x19c9,0x19cf,0xfe12,1,1,
-1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
-1,1,0x894,1,0x19d5,1,1,1,1,0xfe12,1,1,1,1,1,1,
-1,0xfea8,0xfcb6,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xfe0e,1,1,0x898,0x19db,1,0xfc00,1,1,1,0x89c,0x19e1,0x19e7,1,0xdc4,0x19ef,
-1,0xfe12,1,1,1,1,1,1,1,0xfc00,0xfc00,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xfe12,0xfe12,1,0xfc00,1,1,1,1,1,
-1,1,0x8a8,0x8b0,1,1,0x19f7,0x19fd,0x1a03,0xfe12,1,1,1,1,1,1,
-1,1,1,0xfc00,1,1,1,1,1,1,1,1,1,1,0xfc12,1,
-1,1,1,0xfc00,1,1,1,1,1,1,1,1,1,0x8b4,0x1a09,1,
-0xdce,0x1a11,0x1a19,0xfc00,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xfece,0xfece,0xfe12,1,
-1,1,1,1,1,1,1,1,0xfed6,0xfed6,0xfed6,0xfed6,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xfeec,0xfeec,1,1,1,1,1,1,1,1,1,1,
-0xfef4,0xfef4,0xfef4,0xfef4,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,0xffb8,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,0xffb8,1,0xffb8,1,0xffb0,1,1,1,1,1,1,
-1,1,1,0x2a4f,1,1,1,1,1,1,1,1,1,0x2a55,1,1,
-1,1,0x2a5b,1,1,1,1,0x2a61,1,1,1,1,0x2a67,1,1,1,
-1,1,1,1,1,1,1,1,1,0x2a6d,1,1,1,1,1,1,
-1,0xff02,0xff04,0x3c40,0xff08,0x3c48,0x2a72,1,0x2a78,1,0xff04,0xff04,0xff04,0xff04,1,1,
-0xff04,0x3c50,0xffcc,0xffcc,0xfe12,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
-1,1,1,0x2a7f,1,1,1,1,1,1,1,1,1,0x2a85,1,1,
-1,1,0x2a8b,1,1,1,1,0x2a91,1,1,1,1,0x2a97,1,1,1,
-1,1,1,1,1,1,1,1,1,0x2a9d,1,1,1,1,1,1,
-1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,0x8c0,0x1a1f,1,
-1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,0xfe0e,
-1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,
-1,1,1,1,1,1,1,1,1,0xffcc,1,1,1,1,1,1,
-1,1,1,1,1,0xffc8,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xffbc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffb8,1,1,1,
-1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,
-0xffcc,0xffb8,1,1,1,1,1,1,1,0x8c4,0x1a25,0x8c8,0x1a2b,0x8cc,0x1a31,0x8d0,
-0x1a37,0x8d4,0x1a3d,1,1,0x8d8,0x1a43,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,0xfc00,1,1,
-1,1,0x8dc,0x1a49,0x8e0,0x1a4f,0x8e4,0x8e8,0x1a55,0x1a5b,0x8ec,0x1a61,0xfe12,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,
+0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xa66,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x7d4,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x7dc,0x2c9,0x2c9,0x2c9,0x7df,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x7e6,0x7ea,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x7f2,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x7f9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x800,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x709,0x6ab,0x805,0x80d,0x2c9,0x2c9,0x815,0x81c,0x2c9,0x598,0x2c9,0x2c9,0x824,0x2c9,0x2c9,0x827,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x82d,0x2c9,0x830,0x838,0x83f,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x847,0x2c9,0x2c9,0x84f,0x857,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x85c,0x864,0x2c9,0x2c9,0x6ab,
+0x2c9,0x2c9,0x2c9,0x867,0x2c9,0x2c9,0x2c9,0x86d,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x870,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x542,0x86e,
+0x2c9,0x877,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x6ab,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x87f,0x2c9,0x882,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x888,0x2c9,0x88e,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x894,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x89c,0x8a4,0x8ac,0x8b2,0x8ba,0x2c9,0x2c9,0x2c9,0x8c2,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x8ca,0x8d2,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x8d6,0x2c9,0x2c9,0x2c9,
+0x8dd,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x8e5,0x8ed,0x8f5,0x8fd,0x905,0x90d,0x915,0x91d,0x925,0x92d,
+0x935,0x93d,0x945,0x94d,0x955,0x95d,0x965,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,
+0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2c9,0x2a9,0x2a9,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,4,8,0xc,1,1,0x10,0x50,0x5c,0x70,0x88,0xcc,0xd0,
+0xec,0x108,0x144,0x148,0x15c,0x174,0x180,0x1a4,0x1e4,1,0x1ec,0x20c,0x228,0x244,0x290,0x298,
+0x2b0,0x2b8,0x2dc,1,1,1,1,1,1,0x2f4,0x334,0x340,0x354,0x36c,0x3b0,0x3b4,
+0x3d0,0x3f0,0x428,0x430,0x444,0x45c,0x468,0x48c,0x4cc,1,0x4d4,0x4f4,0x510,0x530,0x57c,0x584,
+0x5a0,0x5a8,0x5d0,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x5e8,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x1284,0x128a,0xade,0x1290,0xaf4,0xafe,0x5f4,0xb08,0x1296,0x129c,0xb12,0x12a2,0x12a8,0x12ae,0x12b4,0xb28,
+1,0x12ba,0x12c0,0x12c6,0xb32,0xb48,0xb5a,1,0x5fc,0x12cc,0x12d2,0x12d8,0xb64,0x12de,1,1,
+0x12e4,0x12ea,0xb7a,0x12f0,0xb90,0xb9a,0x600,0xba4,0x12f6,0x12fc,0xbae,0x1302,0x1308,0x130e,0x1314,0xbc4,
+1,0x131a,0x1320,0x1326,0xbce,0xbe4,0xbf6,1,0x608,0x132c,0x1332,0x1338,0xc00,0x133e,1,0x1344,
+0x134a,0x1350,0xc16,0xc2c,0x1357,0x135d,0x1362,0x1368,0x136e,0x1374,0x137a,0x1380,0x1386,0x138c,0x1392,0x1398,
+1,1,0xc42,0xc50,0x139e,0x13a4,0x13aa,0x13b0,0x13b7,0x13bd,0x13c2,0x13c8,0x13ce,0x13d4,0x13da,0x13e0,
+0x13e6,0x13ec,0x13f3,0x13f9,0x13fe,0x1404,1,1,0x140a,0x1410,0x1416,0x141c,0x1422,0x1428,0x142f,0x1435,
+0x143a,1,1,1,0x1441,0x1447,0x144d,0x1453,1,0x1458,0x145e,0x1465,0x146b,0x1470,0x1476,1,
+1,1,1,0x147c,0x1482,0x1489,0x148f,0x1494,0x149a,1,1,1,0xc5e,0xc6c,0x14a0,0x14a6,
+0x14ac,0x14b2,1,1,0x14b8,0x14be,0x14c5,0x14cb,0x14d0,0x14d6,0xc7a,0xc84,0x14dc,0x14e2,0x14e9,0x14ef,
+0xc8e,0xc98,0x14f5,0x14fb,0x1500,0x1506,1,1,0xca2,0xcac,0xcb6,0xcc0,0x150c,0x1512,0x1518,0x151e,
+0x1524,0x152a,0x1531,0x1537,0x153c,0x1542,0x1548,0x154e,0x1554,0x155a,0x1560,0x1566,0x156c,0x1572,0x1578,0x60c,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xcca,0xce4,1,1,1,1,1,1,1,1,1,1,1,1,1,0xcfe,
+0xd18,1,1,1,1,1,1,0x610,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0x157e,0x1584,0x158a,0x1590,0x1596,0x159c,0x15a2,0x15a8,0x15b0,0x15ba,0x15c4,
+0x15ce,0x15d8,0x15e2,0x15ec,0x15f6,1,0x1600,0x160a,0x1614,0x161e,0x1627,0x162d,1,1,0x1632,0x1638,
+0x163e,0x1644,0xd32,0xd3c,0x164d,0x1657,0x165f,0x1665,0x166b,1,1,1,0x1670,0x1676,1,1,
+0x167c,0x1682,0x168a,0x1694,0x169d,0x16a3,0x16a9,0x16af,0x16b4,0x16ba,0x16c0,0x16c6,0x16cc,0x16d2,0x16d8,0x16de,
+0x16e4,0x16ea,0x16f0,0x16f6,0x16fc,0x1702,0x1708,0x170e,0x1714,0x171a,0x1720,0x1726,0x172c,0x1732,0x1738,0x173e,
+0x1744,0x174a,0x1750,0x1756,1,1,0x175c,0x1762,1,1,1,1,1,1,0xd46,0xd50,
+0xd5a,0xd64,0x176a,0x1774,0x177e,0x1788,0xd6e,0xd78,0x1792,0x179c,0x17a4,0x17aa,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x614,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfdcc,0xfdcc,0xfdcc,0xfdcc,
+0xfdcc,0xffcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xfdcc,0xffcc,0xffcc,0xfdcc,0xffcc,0xfdcc,0xffcc,0xfdcc,
+0xfdcc,0xffd0,0xffb8,0xffb8,0xffb8,0xffb8,0xffd0,0xfdb0,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xff94,0xff94,0xfdb8,
+0xfdb8,0xfdb8,0xfdb8,0xfd94,0xfd94,0xffb8,0xffb8,0xffb8,0xffb8,0xfdb8,0xfdb8,0xffb8,0xfdb8,0xfdb8,0xffb8,0xffb8,
+0xfe02,0xfe02,0xfe02,0xfe02,0xfc02,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0x3c26,0x3c2c,0xfdcc,0x3c32,
+0x3c38,0xfde0,0xffcc,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,1,0xffcc,0xffcc,0xffcc,0xffb8,
+0xffb8,0xffb8,0xffb8,0xffcc,0xffd0,0xffb8,0xffb8,0xffcc,0xffd2,0xffd4,0xffd4,0xffd2,0xffd4,0xffd4,0xffd2,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
+0x29d1,1,1,1,1,1,1,1,1,1,0x29d5,1,1,1,1,1,
+1,0x17b1,0x17b7,0x29d9,0x17bd,0x17c3,0x17c9,1,0x17cf,1,0x17d5,0x17db,0x17e3,0x618,1,1,
+1,0x634,1,0x644,1,0x658,1,1,1,1,1,0x674,1,0x684,1,1,
+1,0x688,1,1,1,0x6a0,0x17eb,0x17f1,0xd82,0x17f7,0xd8c,0x17fd,0x1805,0x6b4,1,1,
+1,0x6d4,1,0x6e4,1,0x6fc,1,1,1,1,1,0x71c,1,0x72c,1,1,
+1,0x734,1,1,1,0x754,0xd96,0xda8,0x180d,0x1813,0xdba,1,1,1,0x76c,0x1819,
+0x181f,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x1825,0x182b,1,0x1831,
+1,1,0x774,0x1837,1,1,1,1,0x183d,0x1843,0x1849,1,0x778,1,1,0x780,
+1,0x784,0x790,0x798,0x79c,0x184f,0x7ac,1,1,1,0x7b0,1,1,1,1,0x7b4,
+1,1,1,0x7c4,1,1,1,0x7c8,1,0x7cc,1,1,0x7d0,1,1,0x7d8,
+1,0x7dc,0x7e8,0x7f0,0x7f4,0x1855,0x804,1,1,1,0x808,1,1,1,1,0x80c,
+1,1,1,0x81c,1,1,1,0x820,1,0x824,1,1,0x185b,0x1861,1,0x1867,
+1,1,0x828,0x186d,1,1,1,1,0x1873,0x1879,0x187f,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x82c,0x830,0x1885,0x188b,1,1,1,1,1,1,1,1,1,1,1,0xffcc,
 0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0xfe0e,1,1,1,1,1,
-1,1,1,1,1,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,1,0xfe02,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,
-0xffcc,1,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,1,0xffb8,1,1,
-1,1,1,1,0xffcc,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffd4,0xffac,0xffb8,
-0xff94,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffd0,0xffc8,0xffc8,0xffb8,1,0xffcc,
-0xffd2,0xffb8,0xffcc,0xffb8,0x1a66,0x1a6c,0x1a72,0x1a78,0x1a7f,0x1a85,0x1a8b,0x1a91,0x1a99,0x1aa3,0x1aaa,0x1ab0,
-0x1ab6,0x1abc,0x1ac2,0x1ac8,0x1acf,0x1ad5,0x1ada,0x1ae0,0x1ae8,0x1af2,0x1afc,0x1b06,0x1b0e,0x1b14,0x1b1a,0x1b20,
-0x1b29,0x1b33,0x1b3b,0x1b41,0x1b46,0x1b4c,0x1b52,0x1b58,0x1b5e,0x1b64,0x1b6a,0x1b70,0x1b77,0x1b7d,0x1b82,0x1b88,
-0x1b8e,0x1b94,0x1b9c,0x1ba6,0x1bae,0x1bb4,0x1bba,0x1bc0,0x1bc6,0x1bcc,0xdd8,0xde2,0x1bd4,0x1bde,0x1be6,0x1bec,
-0x1bf2,0x1bf8,0x1bfe,0x1c04,0x1c0a,0x1c10,0x1c17,0x1c1d,0x1c22,0x1c28,0x1c2e,0x1c34,0x1c3a,0x1c40,0x1c46,0x1c4c,
-0x1c54,0x1c5e,0x1c68,0x1c72,0x1c7c,0x1c86,0x1c90,0x1c9a,0x1ca3,0x1ca9,0x1caf,0x1cb5,0x1cba,0x1cc0,0xdec,0xdf6,
-0x1cc8,0x1cd2,0x1cda,0x1ce0,0x1ce6,0x1cec,0xe00,0xe0a,0x1cf4,0x1cfe,0x1d08,0x1d12,0x1d1c,0x1d26,0x1d2e,0x1d34,
-0x1d3a,0x1d40,0x1d46,0x1d4c,0x1d52,0x1d58,0x1d5e,0x1d64,0x1d6a,0x1d70,0x1d76,0x1d7c,0x1d84,0x1d8e,0x1d98,0x1da2,
-0x1daa,0x1db0,0x1db7,0x1dbd,0x1dc2,0x1dc8,0x1dce,0x1dd4,0x1dda,0x1de0,0x1de6,0x1dec,0x1df3,0x1df9,0x1dff,0x1e05,
-0x1e0b,0x1e11,0x1e16,0x1e1c,0x1e22,0x1e28,0x1e2f,0x1e35,0x1e3b,0x1e41,0x1e46,0x1e4c,0x1e52,0x1e58,1,0x1e5f,
-1,1,1,1,0xe14,0xe22,0x1e64,0x1e6a,0x1e72,0x1e7c,0x1e86,0x1e90,0x1e9a,0x1ea4,0x1eae,0x1eb8,
-0x1ec2,0x1ecc,0x1ed6,0x1ee0,0x1eea,0x1ef4,0x1efe,0x1f08,0x1f12,0x1f1c,0x1f26,0x1f30,0xe30,0xe3a,0x1f38,0x1f3e,
-0x1f44,0x1f4a,0x1f52,0x1f5c,0x1f66,0x1f70,0x1f7a,0x1f84,0x1f8e,0x1f98,0x1fa2,0x1fac,0x1fb4,0x1fba,0x1fc0,0x1fc6,
-0xe44,0xe4e,0x1fcc,0x1fd2,0x1fda,0x1fe4,0x1fee,0x1ff8,0x2002,0x200c,0x2016,0x2020,0x202a,0x2034,0x203e,0x2048,
-0x2052,0x205c,0x2066,0x2070,0x207a,0x2084,0x208e,0x2098,0x20a0,0x20a6,0x20ac,0x20b2,0x20ba,0x20c4,0x20ce,0x20d8,
-0x20e2,0x20ec,0x20f6,0x2100,0x210a,0x2114,0x211c,0x2122,0x2129,0x212f,0x2134,0x213a,0x2140,0x2146,1,1,
-1,1,1,1,0xe58,0xe6e,0xe86,0xe94,0xea2,0xeb0,0xebe,0xecc,0xed8,0xeee,0xf06,0xf14,
-0xf22,0xf30,0xf3e,0xf4c,0xf58,0xf66,0x214f,0x2159,0x2163,0x216d,1,1,0xf74,0xf82,0x2177,0x2181,
-0x218b,0x2195,1,1,0xf90,0xfa6,0xfbe,0xfcc,0xfda,0xfe8,0xff6,0x1004,0x1010,0x1026,0x103e,0x104c,
-0x105a,0x1068,0x1076,0x1084,0x1090,0x10a2,0x219f,0x21a9,0x21b3,0x21bd,0x21c7,0x21d1,0x10b4,0x10c6,0x21db,0x21e5,
-0x21ef,0x21f9,0x2203,0x220d,0x10d8,0x10e6,0x2217,0x2221,0x222b,0x2235,1,1,0x10f4,0x1102,0x223f,0x2249,
-0x2253,0x225d,1,1,0x1110,0x1122,0x2267,0x2271,0x227b,0x2285,0x228f,0x2299,1,0x1134,1,0x22a3,
-1,0x22ad,1,0x22b7,0x1146,0x115c,0x1174,0x1182,0x1190,0x119e,0x11ac,0x11ba,0x11c6,0x11dc,0x11f4,0x1202,
-0x1210,0x121e,0x122c,0x123a,0x1246,0x3b8e,0x22bf,0x3b96,0x1250,0x3b9e,0x22c5,0x3ba6,0x22cb,0x3bae,0x22d1,0x3bb6,
-0x125a,0x3bbe,1,1,0x22d8,0x22e2,0x22f1,0x2301,0x2311,0x2321,0x2331,0x2341,0x234c,0x2356,0x2365,0x2375,
-0x2385,0x2395,0x23a5,0x23b5,0x23c0,0x23ca,0x23d9,0x23e9,0x23f9,0x2409,0x2419,0x2429,0x2434,0x243e,0x244d,0x245d,
-0x246d,0x247d,0x248d,0x249d,0x24a8,0x24b2,0x24c1,0x24d1,0x24e1,0x24f1,0x2501,0x2511,0x251c,0x2526,0x2535,0x2545,
-0x2555,0x2565,0x2575,0x2585,0x258f,0x2595,0x259d,0x25a4,0x25ad,1,0x1264,0x25b7,0x25bf,0x25c5,0x25cb,0x3bc6,
-0x25d0,1,0x2aa2,0x8f0,1,0x25d7,0x25df,0x25e6,0x25ef,1,0x126e,0x25f9,0x2601,0x3bce,0x2607,0x3bd6,
-0x260c,0x2613,0x2619,0x261f,0x2625,0x262b,0x2633,0x3be0,1,1,0x263b,0x2643,0x264b,0x2651,0x2657,0x3bea,
-1,0x265d,0x2663,0x2669,0x266f,0x2675,0x267d,0x3bf4,0x2685,0x268b,0x2691,0x2699,0x26a1,0x26a7,0x26ad,0x3bfe,
-0x26b3,0x26b9,0x3c06,0x2aa7,1,1,0x26c1,0x26c8,0x26d1,1,0x1278,0x26db,0x26e3,0x3c0e,0x26e9,0x3c16,
-0x26ee,0x2aab,0x8fc,1,0xfa09,0xfa09,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xffcc,0xffcc,0xfe02,0xfe02,0xffcc,0xffcc,0xffcc,0xffcc,0xfe02,0xfe02,0xfe02,0xffcc,
-0xffcc,1,1,1,1,0xffcc,1,1,1,0xfe02,0xfe02,0xffcc,0xffb8,0xffcc,0xfe02,0xfe02,
-0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0x2aae,1,1,1,0x2ab2,0x3c1e,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0x908,1,0x90c,1,0x910,1,1,1,1,1,0x26f5,0x26fb,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x2701,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,0x2707,0x270d,0x2713,
-0x914,1,0x918,1,0x91c,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0x920,0x2719,1,1,1,0x924,0x271f,1,0x928,0x2725,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0x92c,0x272b,0x930,0x2731,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0x934,1,1,1,
-1,0x2737,1,0x938,0x273d,0x93c,1,0x2743,0x940,0x2749,1,1,1,0x944,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0x274f,0x948,0x2755,1,0x94c,0x950,1,1,1,1,1,1,1,0x275b,0x2761,0x2767,
-0x276d,0x2773,0x954,0x958,0x2779,0x277f,0x95c,0x960,0x2785,0x278b,0x964,0x968,0x96c,0x970,1,1,
-0x2791,0x2797,0x974,0x978,0x279d,0x27a3,0x97c,0x980,0x27a9,0x27af,1,1,1,1,1,1,
-1,0x984,0x988,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,0x98c,1,1,1,1,1,0x990,0x994,1,0x998,0x27b5,0x27bb,0x27c1,0x27c7,
-1,1,0x99c,0x9a0,0x9a4,0x9a8,1,1,1,1,1,1,1,1,1,1,
-0x27cd,0x27d3,0x27d9,0x27df,1,1,1,1,1,1,0x27e5,0x27eb,0x27f1,0x27f7,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0x2ab7,0x2abb,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0x2abf,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xfe12,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
-1,1,0xffb4,0xffc8,0xffd0,0xffbc,0xffc0,0xffc0,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x9ac,1,1,1,1,0x9b0,
-0x27fd,0x9b4,0x2803,0x9b8,0x2809,0x9bc,0x280f,0x9c0,0x2815,0x9c4,0x281b,0x9c8,0x2821,0x9cc,0x2827,0x9d0,
-0x282d,0x9d4,0x2833,0x9d8,0x2839,0x9dc,0x283f,1,0x9e0,0x2845,0x9e4,0x284b,0x9e8,0x2851,1,1,
-1,1,1,0x9ec,0x2857,0x285d,0x9f4,0x2863,0x2869,0x9fc,0x286f,0x2875,0xa04,0x287b,0x2881,0xa0c,
-0x2887,0x288d,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0x2893,1,1,1,1,0xfc10,0xfc10,1,
-1,0xa14,0x2899,1,1,1,1,1,1,1,0xa18,1,1,1,1,0xa1c,
-0x289f,0xa20,0x28a5,0xa24,0x28ab,0xa28,0x28b1,0xa2c,0x28b7,0xa30,0x28bd,0xa34,0x28c3,0xa38,0x28c9,0xa3c,
-0x28cf,0xa40,0x28d5,0xa44,0x28db,0xa48,0x28e1,1,0xa4c,0x28e7,0xa50,0x28ed,0xa54,0x28f3,1,1,
-1,1,1,0xa58,0x28f9,0x28ff,0xa60,0x2905,0x290b,0xa68,0x2911,0x2917,0xa70,0x291d,0x2923,0xa78,
-0x2929,0x292f,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0xa80,0xa84,0xa88,0xa8c,1,0x2935,1,1,0x293b,0x2941,0x2947,0x294d,1,
-1,0xa90,0x2953,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,0xffcc,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,
-0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,
-1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x1891,0x1897,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x189d,0x18a3,0x18a9,0x18af,
+1,1,0x18b5,0x18bb,0x834,0x838,0x18c1,0x18c7,0x18cd,0x18d3,0x18d9,0x18df,1,1,0x18e5,0x18eb,
+0x18f1,0x18f7,0x18fd,0x1903,0x83c,0x840,0x1909,0x190f,0x1915,0x191b,0x1921,0x1927,0x192d,0x1933,0x1939,0x193f,
+0x1945,0x194b,1,1,0x1951,0x1957,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,
+0xffcc,0xffcc,0xffbc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,
+0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffbc,0xffc8,0xffcc,0xfe14,0xfe16,0xfe18,0xfe1a,0xfe1c,0xfe1e,0xfe20,0xfe22,
+0xfe24,0xfe26,0xfe26,0xfe28,0xfe2a,0xfe2c,1,0xfe2e,1,0xfe30,0xfe32,1,0xffcc,0xffb8,1,0xfe24,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xfe3c,0xfe3e,0xfe40,1,1,1,1,1,1,1,0x195c,0x1962,0x1969,0x196f,0x1975,0x844,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0x850,1,0x854,0xfe36,0xfe38,0xfe3a,0xfe3c,0xfe3e,
+0xfe40,0xfe42,0xfe44,0xfdcc,0xfdcc,0xfdb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xfe46,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x197b,0x858,0x1981,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0x85c,0x1987,1,0x860,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,1,1,0xffcc,0xffcc,1,0xffb8,0xffcc,0xffcc,0xffb8,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xffcc,1,0xffcc,0xffcc,0xffb8,1,1,0xffcc,0xffcc,1,1,1,
-1,1,0xffcc,0xffcc,1,0xffcc,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,
-0x2ac5,0x2ac9,0x2acd,0x2ad1,0x2ad5,0x2ad9,0x2add,0x2ae1,0x2ae1,0x2ae5,0x2ae9,0x2aed,0x2af1,0x2af5,0x2af9,0x2afd,
-0x2b01,0x2b05,0x2b09,0x2b0d,0x2b11,0x2b15,0x2b19,0x2b1d,0x2b21,0x2b25,0x2b29,0x2b2d,0x2b31,0x2b35,0x2b39,0x2b3d,
-0x2b41,0x2b45,0x2b49,0x2b4d,0x2b51,0x2b55,0x2b59,0x2b5d,0x2b61,0x2b65,0x2b69,0x2b6d,0x2b71,0x2b75,0x2b79,0x2b7d,
-0x2b81,0x2b85,0x2b89,0x2b8d,0x2b91,0x2b95,0x2b99,0x2b9d,0x2ba1,0x2ba5,0x2ba9,0x2bad,0x2bb1,0x2bb5,0x2bb9,0x2bbd,
-0x2bc1,0x2bc5,0x2bc9,0x2bcd,0x2bd1,0x2bd5,0x2bd9,0x2bdd,0x2be1,0x2be5,0x2be9,0x2bed,0x2bf1,0x2bf5,0x2bf9,0x2bfd,
-0x2c01,0x2c05,0x2c09,0x2c0d,0x2c11,0x2c15,0x2c19,0x2c1d,0x2c21,0x2c25,0x2c29,0x2c2d,0x2b11,0x2c31,0x2c35,0x2c39,
-0x2c3d,0x2c41,0x2c45,0x2c49,0x2c4d,0x2c51,0x2c55,0x2c59,0x2c5d,0x2c61,0x2c65,0x2c69,0x2c6d,0x2c71,0x2c75,0x2c79,
-0x2c7d,0x2c81,0x2c85,0x2c89,0x2c8d,0x2c91,0x2c95,0x2c99,0x2c9d,0x2ca1,0x2ca5,0x2ca9,0x2cad,0x2cb1,0x2cb5,0x2cb9,
-0x2cbd,0x2cc1,0x2cc5,0x2cc9,0x2ccd,0x2cd1,0x2cd5,0x2cd9,0x2cdd,0x2ce1,0x2ce5,0x2ce9,0x2ced,0x2cf1,0x2cf5,0x2cf9,
-0x2cfd,0x2d01,0x2d05,0x2d09,0x2d0d,0x2d11,0x2d15,0x2d19,0x2d1d,0x2d21,0x2d25,0x2d29,0x2d2d,0x2d31,0x2d35,0x2d39,
-0x2d3d,0x2c79,0x2d41,0x2d45,0x2d49,0x2d4d,0x2d51,0x2d55,0x2d59,0x2d5d,0x2c39,0x2d61,0x2d65,0x2d69,0x2d6d,0x2d71,
-0x2d75,0x2d79,0x2d7d,0x2d81,0x2d85,0x2d89,0x2d8d,0x2d91,0x2d95,0x2d99,0x2d9d,0x2da1,0x2da5,0x2da9,0x2dad,0x2b11,
-0x2db1,0x2db5,0x2db9,0x2dbd,0x2dc1,0x2dc5,0x2dc9,0x2dcd,0x2dd1,0x2dd5,0x2dd9,0x2ddd,0x2de1,0x2de5,0x2de9,0x2ded,
-0x2df1,0x2df5,0x2df9,0x2dfd,0x2e01,0x2e05,0x2e09,0x2e0d,0x2e11,0x2e15,0x2e19,0x2c41,0x2e1d,0x2e21,0x2e25,0x2e29,
-0x2e2d,0x2e31,0x2e35,0x2e39,0x2e3d,0x2e41,0x2e45,0x2e49,0x2e4d,0x2e51,0x2e55,0x2e59,0x2e5d,0x2e61,0x2e65,0x2e69,
-0x2e6d,0x2e71,0x2e75,0x2e79,0x2e7d,0x2e81,0x2e85,0x2e89,0x2e8d,0x2e91,0x2e95,0x2e99,0x2e9d,0x2ea1,0x2ea5,0x2ea9,
-0x2ead,0x2eb1,0x2eb5,0x2eb9,0x2ebd,0x2ec1,0x2ec5,0x2ec9,0x2ecd,0x2ed1,0x2ed5,0x2ed9,0x2edd,0x2ee1,1,1,
-0x2ee5,1,0x2ee9,1,1,0x2eed,0x2ef1,0x2ef5,0x2ef9,0x2efd,0x2f01,0x2f05,0x2f09,0x2f0d,0x2f11,1,
-0x2f15,1,0x2f19,1,1,0x2f1d,0x2f21,1,1,1,0x2f25,0x2f29,0x2f2d,0x2f31,0x2f35,0x2f39,
-0x2f3d,0x2f41,0x2f45,0x2f49,0x2f4d,0x2f51,0x2f55,0x2f59,0x2f5d,0x2f61,0x2f65,0x2f69,0x2f6d,0x2f71,0x2f75,0x2f79,
-0x2f7d,0x2f81,0x2f85,0x2f89,0x2f8d,0x2f91,0x2f95,0x2f99,0x2f9d,0x2fa1,0x2fa5,0x2fa9,0x2fad,0x2fb1,0x2fb5,0x2fb9,
-0x2fbd,0x2fc1,0x2fc5,0x2fc9,0x2fcd,0x2fd1,0x2fd5,0x2d15,0x2fd9,0x2fdd,0x2fe1,0x2fe5,0x2fe9,0x2fed,0x2fed,0x2ff1,
-0x2ff5,0x2ff9,0x2ffd,0x3001,0x3005,0x3009,0x300d,0x2f1d,0x3011,0x3015,0x3019,0x301d,0x3021,0x3027,1,1,
-0x302b,0x302f,0x3033,0x3037,0x303b,0x303f,0x3043,0x3047,0x2f55,0x304b,0x304f,0x3053,0x2ee5,0x3057,0x305b,0x305f,
-0x3063,0x3067,0x306b,0x306f,0x3073,0x3077,0x307b,0x307f,0x3083,0x2f79,0x3087,0x2f7d,0x308b,0x308f,0x3093,0x3097,
-0x309b,0x2ee9,0x2b65,0x309f,0x30a3,0x30a7,0x2c7d,0x2dd9,0x30ab,0x30af,0x2f99,0x30b3,0x2f9d,0x30b7,0x30bb,0x30bf,
-0x2ef1,0x30c3,0x30c7,0x30cb,0x30cf,0x30d3,0x2ef5,0x30d7,0x30db,0x30df,0x30e3,0x30e7,0x30eb,0x2fd5,0x30ef,0x30f3,
-0x2d15,0x30f7,0x2fe5,0x30fb,0x30ff,0x3103,0x3107,0x310b,0x2ff9,0x310f,0x2f19,0x3113,0x2ffd,0x2c31,0x3117,0x3001,
-0x311b,0x3009,0x311f,0x3123,0x3127,0x312b,0x312f,0x3011,0x2f09,0x3133,0x3015,0x3137,0x3019,0x313b,0x2ae1,0x313f,
-0x3145,0x314b,0x3151,0x3155,0x3159,0x315d,0x3163,0x3169,0x316f,0x3173,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0x3176,0xfe34,0x317c,1,1,1,1,
-1,1,1,1,1,1,0x3182,0x3188,0x3190,0x319a,0x31a2,0x31a8,0x31ae,0x31b4,0x31ba,0x31c0,
-0x31c6,0x31cc,0x31d2,1,0x31d8,0x31de,0x31e4,0x31ea,0x31f0,1,0x31f6,1,0x31fc,0x3202,1,0x3208,
-0x320e,1,0x3214,0x321a,0x3220,0x3226,0x322c,0x3232,0x3238,0x323e,0x3244,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0xffb8,1,1,0xffb8,1,1,1,
+1,0xfe48,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffcc,0xffb8,0xffb8,0xffcc,0xffb8,0xffcc,
+0xffcc,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,0xffb8,0xffcc,0xffcc,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,1,1,1,1,
+1,1,1,1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xffb8,1,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xfe02,0xffb8,1,
-1,1,1,0xfe12,1,1,1,1,1,0xffcc,0xffb8,1,1,1,1,1,
+0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,0xffb8,0xffb8,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,0xa94,0x2959,0xa9a,0x2963,1,1,1,1,1,1,1,
-1,0xaa0,1,1,1,1,1,0x296d,1,1,1,1,1,1,1,1,
-1,1,1,1,1,0xfe12,0xfc0e,1,1,1,1,1,0xffcc,0xffcc,0xffcc,1,
+1,1,1,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,1,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,
+0xfe36,0xfe38,0xfe3a,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+1,1,1,1,1,1,1,1,0x864,0x198d,1,1,1,1,1,1,
+0x868,0x1993,1,0x86c,0x1999,1,1,1,1,1,1,1,0xfc0e,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,
+1,0xffcc,0xffb8,0xffcc,0xffcc,1,1,1,0x29dc,0x29e2,0x29e8,0x29ee,0x29f4,0x29fa,0x2a00,0x2a06,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,
-1,1,1,1,1,1,0x2977,0x2981,1,0xaa6,0xaac,0xfe12,0xfe12,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,1,0xfc00,1,
+1,1,1,1,1,1,1,0x870,1,1,1,0x199f,0x19a5,0xfe12,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,0x2a0c,0x2a12,1,0x2a18,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0x2a1e,1,1,0x2a24,1,1,1,1,1,0xfe0e,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,
+1,1,1,1,1,1,1,1,1,0x2a2a,0x2a30,0x2a36,1,1,0x2a3c,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0x878,0x19ab,1,1,0x19b1,0x19b7,0xfe12,1,1,1,1,1,1,
+1,1,0xfc00,0xfc00,1,1,1,1,0x2a42,0x2a48,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x884,1,
+0x19bd,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xfc00,1,1,1,1,1,1,1,0x888,0x890,1,1,0x19c3,0x19c9,
+0x19cf,0xfe12,1,1,1,1,1,1,1,1,1,0xfc00,1,1,1,1,
+1,1,1,1,1,1,0x894,1,0x19d5,1,1,1,1,0xfe12,1,1,
+1,1,1,1,1,0xfea8,0xfcb6,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfe0e,1,1,0x898,0x19db,1,0xfc00,1,1,1,0x89c,0x19e1,
+0x19e7,1,0xdc4,0x19ef,1,0xfe12,1,1,1,1,1,1,1,0xfc00,0xfc00,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xfe12,0xfe12,1,0xfc00,1,
+1,1,1,1,1,1,0x8a8,0x8b0,1,1,0x19f7,0x19fd,0x1a03,0xfe12,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
+1,1,0xfc12,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
+1,0x8b4,0x1a09,1,0xdce,0x1a11,0x1a19,0xfc00,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xfece,0xfece,0xfe12,1,1,1,1,1,1,1,1,1,0xfed6,0xfed6,0xfed6,0xfed6,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xfeec,0xfeec,1,1,1,1,1,1,
+1,1,1,1,0xfef4,0xfef4,0xfef4,0xfef4,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0xffb8,1,0xffb8,1,0xffb0,1,1,
+1,1,1,1,1,1,1,0x2a4f,1,1,1,1,1,1,1,1,
+1,0x2a55,1,1,1,1,0x2a5b,1,1,1,1,0x2a61,1,1,1,1,
+0x2a67,1,1,1,1,1,1,1,1,1,1,1,1,0x2a6d,1,1,
+1,1,1,1,1,0xff02,0xff04,0x3c40,0xff08,0x3c48,0x2a72,1,0x2a78,1,0xff04,0xff04,
+0xff04,0xff04,1,1,0xff04,0x3c50,0xffcc,0xffcc,0xfe12,1,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,1,1,1,0x2a7f,1,1,1,1,1,1,1,1,
+1,0x2a85,1,1,1,1,0x2a8b,1,1,1,1,0x2a91,1,1,1,1,
+0x2a97,1,1,1,1,1,1,1,1,1,1,1,1,0x2a9d,1,1,
+1,1,1,1,1,1,0xffb8,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0x8c0,0x1a1f,1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,
+1,1,1,0xfe0e,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xffb8,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,0xffcc,1,1,
+1,1,1,1,1,1,1,1,1,0xffc8,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xffbc,0xffcc,0xffb8,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,
+0xffb8,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffb8,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,
+0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,0xffb8,1,1,1,1,1,1,1,0x8c4,0x1a25,0x8c8,
+0x1a2b,0x8cc,0x1a31,0x8d0,0x1a37,0x8d4,0x1a3d,1,1,0x8d8,0x1a43,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xfe0e,0xfc00,1,1,1,1,0x8dc,0x1a49,0x8e0,0x1a4f,0x8e4,0x8e8,0x1a55,0x1a5b,0x8ec,0x1a61,
+0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xffcc,
+0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xfe12,0xfe12,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe0e,1,
+1,1,1,1,1,1,1,1,1,1,0xfe12,0xfe12,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xfe0e,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xffcc,0xffcc,0xffcc,1,0xfe02,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,
+0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,1,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,
+1,0xffb8,1,1,1,1,1,1,0xffcc,1,1,1,0xffcc,0xffcc,1,1,
+1,1,1,1,0xffcc,0xffcc,0xffb8,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,
+0xffcc,0xffd4,0xffac,0xffb8,0xff94,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffd0,0xffc8,
+0xffc8,0xffb8,1,0xffcc,0xffd2,0xffb8,0xffcc,0xffb8,0x1a66,0x1a6c,0x1a72,0x1a78,0x1a7f,0x1a85,0x1a8b,0x1a91,
+0x1a99,0x1aa3,0x1aaa,0x1ab0,0x1ab6,0x1abc,0x1ac2,0x1ac8,0x1acf,0x1ad5,0x1ada,0x1ae0,0x1ae8,0x1af2,0x1afc,0x1b06,
+0x1b0e,0x1b14,0x1b1a,0x1b20,0x1b29,0x1b33,0x1b3b,0x1b41,0x1b46,0x1b4c,0x1b52,0x1b58,0x1b5e,0x1b64,0x1b6a,0x1b70,
+0x1b77,0x1b7d,0x1b82,0x1b88,0x1b8e,0x1b94,0x1b9c,0x1ba6,0x1bae,0x1bb4,0x1bba,0x1bc0,0x1bc6,0x1bcc,0xdd8,0xde2,
+0x1bd4,0x1bde,0x1be6,0x1bec,0x1bf2,0x1bf8,0x1bfe,0x1c04,0x1c0a,0x1c10,0x1c17,0x1c1d,0x1c22,0x1c28,0x1c2e,0x1c34,
+0x1c3a,0x1c40,0x1c46,0x1c4c,0x1c54,0x1c5e,0x1c68,0x1c72,0x1c7c,0x1c86,0x1c90,0x1c9a,0x1ca3,0x1ca9,0x1caf,0x1cb5,
+0x1cba,0x1cc0,0xdec,0xdf6,0x1cc8,0x1cd2,0x1cda,0x1ce0,0x1ce6,0x1cec,0xe00,0xe0a,0x1cf4,0x1cfe,0x1d08,0x1d12,
+0x1d1c,0x1d26,0x1d2e,0x1d34,0x1d3a,0x1d40,0x1d46,0x1d4c,0x1d52,0x1d58,0x1d5e,0x1d64,0x1d6a,0x1d70,0x1d76,0x1d7c,
+0x1d84,0x1d8e,0x1d98,0x1da2,0x1daa,0x1db0,0x1db7,0x1dbd,0x1dc2,0x1dc8,0x1dce,0x1dd4,0x1dda,0x1de0,0x1de6,0x1dec,
+0x1df3,0x1df9,0x1dff,0x1e05,0x1e0b,0x1e11,0x1e16,0x1e1c,0x1e22,0x1e28,0x1e2f,0x1e35,0x1e3b,0x1e41,0x1e46,0x1e4c,
+0x1e52,0x1e58,1,0x1e5f,1,1,1,1,0xe14,0xe22,0x1e64,0x1e6a,0x1e72,0x1e7c,0x1e86,0x1e90,
+0x1e9a,0x1ea4,0x1eae,0x1eb8,0x1ec2,0x1ecc,0x1ed6,0x1ee0,0x1eea,0x1ef4,0x1efe,0x1f08,0x1f12,0x1f1c,0x1f26,0x1f30,
+0xe30,0xe3a,0x1f38,0x1f3e,0x1f44,0x1f4a,0x1f52,0x1f5c,0x1f66,0x1f70,0x1f7a,0x1f84,0x1f8e,0x1f98,0x1fa2,0x1fac,
+0x1fb4,0x1fba,0x1fc0,0x1fc6,0xe44,0xe4e,0x1fcc,0x1fd2,0x1fda,0x1fe4,0x1fee,0x1ff8,0x2002,0x200c,0x2016,0x2020,
+0x202a,0x2034,0x203e,0x2048,0x2052,0x205c,0x2066,0x2070,0x207a,0x2084,0x208e,0x2098,0x20a0,0x20a6,0x20ac,0x20b2,
+0x20ba,0x20c4,0x20ce,0x20d8,0x20e2,0x20ec,0x20f6,0x2100,0x210a,0x2114,0x211c,0x2122,0x2129,0x212f,0x2134,0x213a,
+0x2140,0x2146,1,1,1,1,1,1,0xe58,0xe6e,0xe86,0xe94,0xea2,0xeb0,0xebe,0xecc,
+0xed8,0xeee,0xf06,0xf14,0xf22,0xf30,0xf3e,0xf4c,0xf58,0xf66,0x214f,0x2159,0x2163,0x216d,1,1,
+0xf74,0xf82,0x2177,0x2181,0x218b,0x2195,1,1,0xf90,0xfa6,0xfbe,0xfcc,0xfda,0xfe8,0xff6,0x1004,
+0x1010,0x1026,0x103e,0x104c,0x105a,0x1068,0x1076,0x1084,0x1090,0x10a2,0x219f,0x21a9,0x21b3,0x21bd,0x21c7,0x21d1,
+0x10b4,0x10c6,0x21db,0x21e5,0x21ef,0x21f9,0x2203,0x220d,0x10d8,0x10e6,0x2217,0x2221,0x222b,0x2235,1,1,
+0x10f4,0x1102,0x223f,0x2249,0x2253,0x225d,1,1,0x1110,0x1122,0x2267,0x2271,0x227b,0x2285,0x228f,0x2299,
+1,0x1134,1,0x22a3,1,0x22ad,1,0x22b7,0x1146,0x115c,0x1174,0x1182,0x1190,0x119e,0x11ac,0x11ba,
+0x11c6,0x11dc,0x11f4,0x1202,0x1210,0x121e,0x122c,0x123a,0x1246,0x3b8e,0x22bf,0x3b96,0x1250,0x3b9e,0x22c5,0x3ba6,
+0x22cb,0x3bae,0x22d1,0x3bb6,0x125a,0x3bbe,1,1,0x22d8,0x22e2,0x22f1,0x2301,0x2311,0x2321,0x2331,0x2341,
+0x234c,0x2356,0x2365,0x2375,0x2385,0x2395,0x23a5,0x23b5,0x23c0,0x23ca,0x23d9,0x23e9,0x23f9,0x2409,0x2419,0x2429,
+0x2434,0x243e,0x244d,0x245d,0x246d,0x247d,0x248d,0x249d,0x24a8,0x24b2,0x24c1,0x24d1,0x24e1,0x24f1,0x2501,0x2511,
+0x251c,0x2526,0x2535,0x2545,0x2555,0x2565,0x2575,0x2585,0x258f,0x2595,0x259d,0x25a4,0x25ad,1,0x1264,0x25b7,
+0x25bf,0x25c5,0x25cb,0x3bc6,0x25d0,1,0x2aa2,0x8f0,1,0x25d7,0x25df,0x25e6,0x25ef,1,0x126e,0x25f9,
+0x2601,0x3bce,0x2607,0x3bd6,0x260c,0x2613,0x2619,0x261f,0x2625,0x262b,0x2633,0x3be0,1,1,0x263b,0x2643,
+0x264b,0x2651,0x2657,0x3bea,1,0x265d,0x2663,0x2669,0x266f,0x2675,0x267d,0x3bf4,0x2685,0x268b,0x2691,0x2699,
+0x26a1,0x26a7,0x26ad,0x3bfe,0x26b3,0x26b9,0x3c06,0x2aa7,1,1,0x26c1,0x26c8,0x26d1,1,0x1278,0x26db,
+0x26e3,0x3c0e,0x26e9,0x3c16,0x26ee,0x2aab,0x8fc,1,0xfa09,0xfa09,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xfe02,0xfe02,0xffcc,0xffcc,0xffcc,0xffcc,
+0xfe02,0xfe02,0xfe02,0xffcc,0xffcc,1,1,1,1,0xffcc,1,1,1,0xfe02,0xfe02,0xffcc,
+0xffb8,0xffcc,0xfe02,0xfe02,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0x2aae,1,1,1,0x2ab2,0x3c1e,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x908,1,0x90c,1,0x910,1,1,1,1,1,0x26f5,0x26fb,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x2701,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0x2707,0x270d,0x2713,0x914,1,0x918,1,0x91c,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0x920,0x2719,1,1,1,0x924,0x271f,1,0x928,
+0x2725,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0x92c,0x272b,0x930,0x2731,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0x934,1,1,1,1,0x2737,1,0x938,0x273d,0x93c,1,0x2743,0x940,0x2749,1,1,
+1,0x944,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x274f,0x948,0x2755,1,0x94c,0x950,1,1,1,1,1,1,
+1,0x275b,0x2761,0x2767,0x276d,0x2773,0x954,0x958,0x2779,0x277f,0x95c,0x960,0x2785,0x278b,0x964,0x968,
+0x96c,0x970,1,1,0x2791,0x2797,0x974,0x978,0x279d,0x27a3,0x97c,0x980,0x27a9,0x27af,1,1,
+1,1,1,1,1,0x984,0x988,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x98c,1,1,1,1,1,0x990,0x994,1,0x998,
+0x27b5,0x27bb,0x27c1,0x27c7,1,1,0x99c,0x9a0,0x9a4,0x9a8,1,1,1,1,1,1,
+1,1,1,1,0x27cd,0x27d3,0x27d9,0x27df,1,1,1,1,1,1,0x27e5,0x27eb,
+0x27f1,0x27f7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0x2ab7,0x2abb,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x2abf,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xfe12,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,1,1,0xffb4,0xffc8,0xffd0,0xffbc,0xffc0,0xffc0,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x9ac,1,
+1,1,1,0x9b0,0x27fd,0x9b4,0x2803,0x9b8,0x2809,0x9bc,0x280f,0x9c0,0x2815,0x9c4,0x281b,0x9c8,
+0x2821,0x9cc,0x2827,0x9d0,0x282d,0x9d4,0x2833,0x9d8,0x2839,0x9dc,0x283f,1,0x9e0,0x2845,0x9e4,0x284b,
+0x9e8,0x2851,1,1,1,1,1,0x9ec,0x2857,0x285d,0x9f4,0x2863,0x2869,0x9fc,0x286f,0x2875,
+0xa04,0x287b,0x2881,0xa0c,0x2887,0x288d,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x2893,1,1,1,
+1,0xfc10,0xfc10,1,1,0xa14,0x2899,1,1,1,1,1,1,1,0xa18,1,
+1,1,1,0xa1c,0x289f,0xa20,0x28a5,0xa24,0x28ab,0xa28,0x28b1,0xa2c,0x28b7,0xa30,0x28bd,0xa34,
+0x28c3,0xa38,0x28c9,0xa3c,0x28cf,0xa40,0x28d5,0xa44,0x28db,0xa48,0x28e1,1,0xa4c,0x28e7,0xa50,0x28ed,
+0xa54,0x28f3,1,1,1,1,1,0xa58,0x28f9,0x28ff,0xa60,0x2905,0x290b,0xa68,0x2911,0x2917,
+0xa70,0x291d,0x2923,0xa78,0x2929,0x292f,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xa80,0xa84,0xa88,0xa8c,1,0x2935,1,1,0x293b,
+0x2941,0x2947,0x294d,1,1,0xa90,0x2953,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xffcc,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0xffb8,0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,
 1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,1,0xffcc,0xffcc,0xffb8,1,1,0xffcc,
+0xffcc,1,1,1,1,1,0xffcc,0xffcc,1,0xffcc,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,
+1,1,1,1,0x2ac5,0x2ac9,0x2acd,0x2ad1,0x2ad5,0x2ad9,0x2add,0x2ae1,0x2ae1,0x2ae5,0x2ae9,0x2aed,
+0x2af1,0x2af5,0x2af9,0x2afd,0x2b01,0x2b05,0x2b09,0x2b0d,0x2b11,0x2b15,0x2b19,0x2b1d,0x2b21,0x2b25,0x2b29,0x2b2d,
+0x2b31,0x2b35,0x2b39,0x2b3d,0x2b41,0x2b45,0x2b49,0x2b4d,0x2b51,0x2b55,0x2b59,0x2b5d,0x2b61,0x2b65,0x2b69,0x2b6d,
+0x2b71,0x2b75,0x2b79,0x2b7d,0x2b81,0x2b85,0x2b89,0x2b8d,0x2b91,0x2b95,0x2b99,0x2b9d,0x2ba1,0x2ba5,0x2ba9,0x2bad,
+0x2bb1,0x2bb5,0x2bb9,0x2bbd,0x2bc1,0x2bc5,0x2bc9,0x2bcd,0x2bd1,0x2bd5,0x2bd9,0x2bdd,0x2be1,0x2be5,0x2be9,0x2bed,
+0x2bf1,0x2bf5,0x2bf9,0x2bfd,0x2c01,0x2c05,0x2c09,0x2c0d,0x2c11,0x2c15,0x2c19,0x2c1d,0x2c21,0x2c25,0x2c29,0x2c2d,
+0x2b11,0x2c31,0x2c35,0x2c39,0x2c3d,0x2c41,0x2c45,0x2c49,0x2c4d,0x2c51,0x2c55,0x2c59,0x2c5d,0x2c61,0x2c65,0x2c69,
+0x2c6d,0x2c71,0x2c75,0x2c79,0x2c7d,0x2c81,0x2c85,0x2c89,0x2c8d,0x2c91,0x2c95,0x2c99,0x2c9d,0x2ca1,0x2ca5,0x2ca9,
+0x2cad,0x2cb1,0x2cb5,0x2cb9,0x2cbd,0x2cc1,0x2cc5,0x2cc9,0x2ccd,0x2cd1,0x2cd5,0x2cd9,0x2cdd,0x2ce1,0x2ce5,0x2ce9,
+0x2ced,0x2cf1,0x2cf5,0x2cf9,0x2cfd,0x2d01,0x2d05,0x2d09,0x2d0d,0x2d11,0x2d15,0x2d19,0x2d1d,0x2d21,0x2d25,0x2d29,
+0x2d2d,0x2d31,0x2d35,0x2d39,0x2d3d,0x2c79,0x2d41,0x2d45,0x2d49,0x2d4d,0x2d51,0x2d55,0x2d59,0x2d5d,0x2c39,0x2d61,
+0x2d65,0x2d69,0x2d6d,0x2d71,0x2d75,0x2d79,0x2d7d,0x2d81,0x2d85,0x2d89,0x2d8d,0x2d91,0x2d95,0x2d99,0x2d9d,0x2da1,
+0x2da5,0x2da9,0x2dad,0x2b11,0x2db1,0x2db5,0x2db9,0x2dbd,0x2dc1,0x2dc5,0x2dc9,0x2dcd,0x2dd1,0x2dd5,0x2dd9,0x2ddd,
+0x2de1,0x2de5,0x2de9,0x2ded,0x2df1,0x2df5,0x2df9,0x2dfd,0x2e01,0x2e05,0x2e09,0x2e0d,0x2e11,0x2e15,0x2e19,0x2c41,
+0x2e1d,0x2e21,0x2e25,0x2e29,0x2e2d,0x2e31,0x2e35,0x2e39,0x2e3d,0x2e41,0x2e45,0x2e49,0x2e4d,0x2e51,0x2e55,0x2e59,
+0x2e5d,0x2e61,0x2e65,0x2e69,0x2e6d,0x2e71,0x2e75,0x2e79,0x2e7d,0x2e81,0x2e85,0x2e89,0x2e8d,0x2e91,0x2e95,0x2e99,
+0x2e9d,0x2ea1,0x2ea5,0x2ea9,0x2ead,0x2eb1,0x2eb5,0x2eb9,0x2ebd,0x2ec1,0x2ec5,0x2ec9,0x2ecd,0x2ed1,0x2ed5,0x2ed9,
+0x2edd,0x2ee1,1,1,0x2ee5,1,0x2ee9,1,1,0x2eed,0x2ef1,0x2ef5,0x2ef9,0x2efd,0x2f01,0x2f05,
+0x2f09,0x2f0d,0x2f11,1,0x2f15,1,0x2f19,1,1,0x2f1d,0x2f21,1,1,1,0x2f25,0x2f29,
+0x2f2d,0x2f31,0x2f35,0x2f39,0x2f3d,0x2f41,0x2f45,0x2f49,0x2f4d,0x2f51,0x2f55,0x2f59,0x2f5d,0x2f61,0x2f65,0x2f69,
+0x2f6d,0x2f71,0x2f75,0x2f79,0x2f7d,0x2f81,0x2f85,0x2f89,0x2f8d,0x2f91,0x2f95,0x2f99,0x2f9d,0x2fa1,0x2fa5,0x2fa9,
+0x2fad,0x2fb1,0x2fb5,0x2fb9,0x2fbd,0x2fc1,0x2fc5,0x2fc9,0x2fcd,0x2fd1,0x2fd5,0x2d15,0x2fd9,0x2fdd,0x2fe1,0x2fe5,
+0x2fe9,0x2fed,0x2fed,0x2ff1,0x2ff5,0x2ff9,0x2ffd,0x3001,0x3005,0x3009,0x300d,0x2f1d,0x3011,0x3015,0x3019,0x301d,
+0x3021,0x3027,1,1,0x302b,0x302f,0x3033,0x3037,0x303b,0x303f,0x3043,0x3047,0x2f55,0x304b,0x304f,0x3053,
+0x2ee5,0x3057,0x305b,0x305f,0x3063,0x3067,0x306b,0x306f,0x3073,0x3077,0x307b,0x307f,0x3083,0x2f79,0x3087,0x2f7d,
+0x308b,0x308f,0x3093,0x3097,0x309b,0x2ee9,0x2b65,0x309f,0x30a3,0x30a7,0x2c7d,0x2dd9,0x30ab,0x30af,0x2f99,0x30b3,
+0x2f9d,0x30b7,0x30bb,0x30bf,0x2ef1,0x30c3,0x30c7,0x30cb,0x30cf,0x30d3,0x2ef5,0x30d7,0x30db,0x30df,0x30e3,0x30e7,
+0x30eb,0x2fd5,0x30ef,0x30f3,0x2d15,0x30f7,0x2fe5,0x30fb,0x30ff,0x3103,0x3107,0x310b,0x2ff9,0x310f,0x2f19,0x3113,
+0x2ffd,0x2c31,0x3117,0x3001,0x311b,0x3009,0x311f,0x3123,0x3127,0x312b,0x312f,0x3011,0x2f09,0x3133,0x3015,0x3137,
+0x3019,0x313b,0x2ae1,0x313f,0x3145,0x314b,0x3151,0x3155,0x3159,0x315d,0x3163,0x3169,0x316f,0x3173,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x3176,0xfe34,0x317c,
+1,1,1,1,1,1,1,1,1,1,0x3182,0x3188,0x3190,0x319a,0x31a2,0x31a8,
+0x31ae,0x31b4,0x31ba,0x31c0,0x31c6,0x31cc,0x31d2,1,0x31d8,0x31de,0x31e4,0x31ea,0x31f0,1,0x31f6,1,
+0x31fc,0x3202,1,0x3208,0x320e,1,0x3214,0x321a,0x3220,0x3226,0x322c,0x3232,0x3238,0x323e,0x3244,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffcc,0xffcc,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xffb8,1,1,
+0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xffb8,1,0xffcc,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xffcc,0xfe02,0xffb8,1,1,1,1,0xfe12,1,1,1,1,1,0xffcc,0xffb8,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0xffb8,0xffb8,0xffcc,0xffcc,0xffcc,0xffb8,0xffcc,0xffb8,0xffb8,0xffb8,
+0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xa94,0x2959,0xa9a,
+0x2963,1,1,1,1,1,1,1,1,0xaa0,1,1,1,1,1,0x296d,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,0xfc0e,1,
+1,1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,0x2977,0x2981,
+1,0xaa6,0xaac,0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,
+0xfe12,1,1,1,1,1,1,1,1,1,0xfe0e,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0xfe12,0xfe0e,1,1,1,1,1,1,1,1,1,1,0xfe0e,0xfe12,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xfe0e,0xfe0e,1,0xfc00,1,
+1,1,1,1,1,1,1,0xab2,1,1,1,0x298b,0x2995,0xfe12,1,1,
+1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
+1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,1,
 1,1,0xfe0e,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xffcc,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,1,1,1,
+1,1,1,1,1,0xabe,0xfc00,0x299f,0x29a9,0xfc00,0x29b3,1,1,1,0xfe12,0xfe0e,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfc00,
+1,1,1,1,1,1,1,1,0xad0,0xad6,0x29bd,0x29c7,1,1,1,0xfe12,
+0xfe0e,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0xfe12,0xfe0e,1,1,1,1,1,1,1,1,1,1,1,0xfe12,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,
-1,1,1,1,1,0xfe0e,0xfe12,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xab2,
-1,1,1,0x298b,0x2995,0xfe12,1,1,1,1,1,1,1,1,1,0xfc00,
-1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0xfe12,1,1,1,0xfe0e,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,0xabe,0xfc00,0x299f,
-0x29a9,0xfc00,0x29b3,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,0xfe0e,1,
+0xfe12,0xfe12,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe12,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xfc00,1,1,1,1,1,1,1,1,
-0xad0,0xad6,0x29bd,0x29c7,1,1,1,0xfe12,0xfe0e,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0xfe12,0xfe0e,1,1,1,1,
-1,1,1,1,1,1,1,0xfe12,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xfe12,1,1,1,1,1,1,1,1,0xfe0e,1,0xfe12,0xfe12,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0xfe02,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,0x324a,0x3254,0x3268,0x3280,0x3298,0x32b0,0x32c8,0xffb0,0xffb0,0xfe02,
-0xfe02,0xfe02,1,1,1,0xffc4,0xffb0,0xffb0,0xffb0,0xffb0,0xffb0,1,1,1,1,1,
-1,1,1,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,1,1,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0x32d6,0x32e0,0x32f4,0x330c,0x3324,
-0x333c,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
-0xffcc,0xffcc,1,0xffcc,0xffcc,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,1,1,1,1,1,1,1,1,1,
-0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xfe0e,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0x334b,0x334f,0x3353,0x3357,
-0x335d,0x2f3d,0x3361,0x3365,0x3369,0x336d,0x2f41,0x3371,0x3375,0x3379,0x2f45,0x337f,0x3383,0x3387,0x338b,0x3391,
-0x3395,0x3399,0x339d,0x33a3,0x33a7,0x33ab,0x33af,0x302f,0x33b3,0x33b9,0x33bd,0x33c1,0x33c5,0x33c9,0x33cd,0x33d1,
-0x33d5,0x3043,0x2f49,0x2f4d,0x3047,0x33d9,0x33dd,0x2c49,0x33e1,0x2f51,0x33e5,0x33e9,0x33ed,0x33f1,0x33f1,0x33f1,
-0x33f5,0x33fb,0x33ff,0x3403,0x3407,0x340d,0x3411,0x3415,0x3419,0x341d,0x3421,0x3425,0x3429,0x342d,0x3431,0x3435,
-0x3439,0x343d,0x343d,0x304f,0x3441,0x3445,0x3449,0x344d,0x2f59,0x3451,0x3455,0x3459,0x2ead,0x345d,0x3461,0x3465,
-0x3469,0x346d,0x3471,0x3475,0x3479,0x347d,0x3483,0x3487,0x348b,0x348f,0x3493,0x3497,0x349b,0x34a1,0x34a7,0x34ab,
-0x34af,0x34b3,0x34b7,0x34bb,0x34bf,0x34c3,0x34c7,0x34c7,0x34cb,0x34d1,0x34d5,0x2c39,0x34d9,0x34dd,0x34e3,0x34e7,
-0x34eb,0x34ef,0x34f3,0x34f7,0x2f6d,0x34fb,0x34ff,0x3503,0x3509,0x350d,0x3513,0x3517,0x351b,0x351f,0x3523,0x3527,
-0x352b,0x352f,0x3533,0x3537,0x353b,0x353f,0x3545,0x3549,0x354d,0x3551,0x2b61,0x3555,0x355b,0x355f,0x355f,0x3565,
-0x3569,0x3569,0x356d,0x3571,0x3577,0x357d,0x3581,0x3585,0x3589,0x358d,0x3591,0x3595,0x3599,0x359d,0x35a1,0x2f71,
-0x35a5,0x35ab,0x35af,0x35b3,0x307f,0x35b3,0x35b7,0x2f79,0x35bb,0x35bf,0x35c3,0x35c7,0x2f7d,0x2af5,0x35cb,0x35cf,
-0x35d3,0x35d7,0x35db,0x35df,0x35e3,0x35e9,0x35ed,0x35f1,0x35f5,0x35f9,0x35fd,0x3603,0x3607,0x360b,0x360f,0x3613,
-0x3617,0x361b,0x361f,0x3623,0x2f81,0x3627,0x362b,0x3631,0x3635,0x3639,0x363d,0x2f89,0x3641,0x3645,0x3649,0x364d,
-0x3651,0x3655,0x3659,0x365d,0x2b65,0x309f,0x3661,0x3665,0x3669,0x366d,0x3673,0x3677,0x367b,0x367f,0x2f8d,0x3683,
-0x3689,0x368d,0x3691,0x3151,0x3695,0x3699,0x369d,0x36a1,0x36a5,0x36ab,0x36af,0x36b3,0x36b7,0x36bd,0x36c1,0x36c5,
-0x36c9,0x2c7d,0x36cd,0x36d1,0x36d7,0x36dd,0x36e3,0x36e7,0x36ed,0x36f1,0x36f5,0x36f9,0x36fd,0x2f91,0x2dd9,0x3701,
-0x3705,0x3709,0x370d,0x3713,0x3717,0x371b,0x371f,0x30af,0x3723,0x3727,0x372d,0x3731,0x3735,0x373b,0x3741,0x3745,
-0x30b3,0x3749,0x374d,0x3751,0x3755,0x3759,0x375d,0x3761,0x3767,0x376b,0x3771,0x3775,0x377b,0x30bb,0x377f,0x3783,
-0x3789,0x378d,0x3791,0x3797,0x379d,0x37a1,0x37a5,0x37a9,0x37ad,0x37ad,0x37b1,0x37b5,0x30c3,0x37b9,0x37bd,0x37c1,
-0x37c5,0x37c9,0x37cf,0x37d3,0x2c45,0x37d9,0x37df,0x37e3,0x37e9,0x37ef,0x37f5,0x37f9,0x30db,0x37fd,0x3803,0x3809,
-0x380f,0x3815,0x3819,0x3819,0x30df,0x3159,0x381d,0x3821,0x3825,0x3829,0x382f,0x2bad,0x30e7,0x3833,0x3837,0x2fbd,
-0x383d,0x3843,0x2f05,0x3849,0x384d,0x2fcd,0x3851,0x3855,0x3859,0x385f,0x385f,0x3865,0x3869,0x386d,0x3873,0x3877,
-0x387b,0x387f,0x3885,0x3889,0x388d,0x3891,0x3895,0x3899,0x389f,0x38a3,0x38a7,0x38ab,0x38af,0x38b3,0x38b7,0x38bd,
-0x38c3,0x38c7,0x38cd,0x38d1,0x38d7,0x38db,0x2fe5,0x38df,0x38e5,0x38eb,0x38ef,0x38f5,0x38f9,0x38ff,0x3903,0x3907,
-0x390b,0x390f,0x3913,0x3917,0x391d,0x3923,0x3929,0x3565,0x392f,0x3933,0x3937,0x393b,0x393f,0x3943,0x3947,0x394b,
-0x394f,0x3953,0x3957,0x395b,0x2c8d,0x3961,0x3965,0x3969,0x396d,0x3971,0x3975,0x2ff1,0x3979,0x397d,0x3981,0x3985,
-0x3989,0x398f,0x3995,0x399b,0x399f,0x39a3,0x39a7,0x39ab,0x39b1,0x39b5,0x39bb,0x39bf,0x39c3,0x39c9,0x39cf,0x39d3,
-0x2b99,0x39d7,0x39db,0x39df,0x39e3,0x39e7,0x39eb,0x3103,0x39ef,0x39f3,0x39f7,0x39fb,0x39ff,0x3a03,0x3a07,0x3a0b,
-0x3a0f,0x3a13,0x3a19,0x3a1d,0x3a21,0x3a25,0x3a29,0x3a2d,0x3a33,0x3a39,0x3a3d,0x3a41,0x3117,0x311b,0x3a45,0x3a49,
-0x3a4f,0x3a53,0x3a57,0x3a5b,0x3a5f,0x3a65,0x3a6b,0x3a6f,0x3a73,0x3a77,0x3a7d,0x311f,0x3a81,0x3a87,0x3a8d,0x3a91,
-0x3a95,0x3a99,0x3a9f,0x3aa3,0x3aa7,0x3aab,0x3aaf,0x3ab3,0x3ab7,0x3abb,0x3ac1,0x3ac5,0x3ac9,0x3acd,0x3ad3,0x3ad7,
-0x3adb,0x3adf,0x3ae3,0x3ae9,0x3aef,0x3af3,0x3af7,0x3afb,0x3b01,0x3b05,0x3137,0x3137,0x3b0b,0x3b0f,0x3b15,0x3b19,
-0x3b1d,0x3b21,0x3b25,0x3b29,0x3b2d,0x3b31,0x313b,0x3b37,0x3b3b,0x3b3f,0x3b43,0x3b47,0x3b4b,0x3b51,0x3b55,0x3b5b,
-0x3b61,0x3b67,0x3b6b,0x3b6f,0x3b73,0x3b77,0x3b7b,0x3b7f,0x3b83,0x3b87,1,1,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe00,0xfe00,0xfe00,
-0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
-0xfe00,0xfe00,1,1,1,1,1,1,1,1,1,1,0xfe00,0xfe00,0xfe00,0xfe00,
-0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
-0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
-0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
-0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
-0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,1,1,1,1,1,1,1,1,
+0xfe02,0xfe02,0xfe02,0xfe02,0xfe02,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xfe02,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x324a,0x3254,
+0x3268,0x3280,0x3298,0x32b0,0x32c8,0xffb0,0xffb0,0xfe02,0xfe02,0xfe02,1,1,1,0xffc4,0xffb0,0xffb0,
+0xffb0,0xffb0,0xffb0,1,1,1,1,1,1,1,1,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,
+0xffb8,0xffb8,0xffb8,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffb8,0xffb8,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0x1283,0x1283,0x1283,0x1283,0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+1,1,0xffcc,0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0x32d6,0x32e0,0x32f4,0x330c,0x3324,0x333c,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,
+0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,
+0xffcc,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,1,0xffcc,0xffcc,1,0xffcc,0xffcc,
+0xffcc,0xffcc,0xffcc,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,0xffb8,1,
+1,1,1,1,1,1,1,1,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xffcc,0xfe0e,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x334b,0x334f,0x3353,0x3357,0x335d,0x2f3d,0x3361,0x3365,0x3369,0x336d,0x2f41,0x3371,
+0x3375,0x3379,0x2f45,0x337f,0x3383,0x3387,0x338b,0x3391,0x3395,0x3399,0x339d,0x33a3,0x33a7,0x33ab,0x33af,0x302f,
+0x33b3,0x33b9,0x33bd,0x33c1,0x33c5,0x33c9,0x33cd,0x33d1,0x33d5,0x3043,0x2f49,0x2f4d,0x3047,0x33d9,0x33dd,0x2c49,
+0x33e1,0x2f51,0x33e5,0x33e9,0x33ed,0x33f1,0x33f1,0x33f1,0x33f5,0x33fb,0x33ff,0x3403,0x3407,0x340d,0x3411,0x3415,
+0x3419,0x341d,0x3421,0x3425,0x3429,0x342d,0x3431,0x3435,0x3439,0x343d,0x343d,0x304f,0x3441,0x3445,0x3449,0x344d,
+0x2f59,0x3451,0x3455,0x3459,0x2ead,0x345d,0x3461,0x3465,0x3469,0x346d,0x3471,0x3475,0x3479,0x347d,0x3483,0x3487,
+0x348b,0x348f,0x3493,0x3497,0x349b,0x34a1,0x34a7,0x34ab,0x34af,0x34b3,0x34b7,0x34bb,0x34bf,0x34c3,0x34c7,0x34c7,
+0x34cb,0x34d1,0x34d5,0x2c39,0x34d9,0x34dd,0x34e3,0x34e7,0x34eb,0x34ef,0x34f3,0x34f7,0x2f6d,0x34fb,0x34ff,0x3503,
+0x3509,0x350d,0x3513,0x3517,0x351b,0x351f,0x3523,0x3527,0x352b,0x352f,0x3533,0x3537,0x353b,0x353f,0x3545,0x3549,
+0x354d,0x3551,0x2b61,0x3555,0x355b,0x355f,0x355f,0x3565,0x3569,0x3569,0x356d,0x3571,0x3577,0x357d,0x3581,0x3585,
+0x3589,0x358d,0x3591,0x3595,0x3599,0x359d,0x35a1,0x2f71,0x35a5,0x35ab,0x35af,0x35b3,0x307f,0x35b3,0x35b7,0x2f79,
+0x35bb,0x35bf,0x35c3,0x35c7,0x2f7d,0x2af5,0x35cb,0x35cf,0x35d3,0x35d7,0x35db,0x35df,0x35e3,0x35e9,0x35ed,0x35f1,
+0x35f5,0x35f9,0x35fd,0x3603,0x3607,0x360b,0x360f,0x3613,0x3617,0x361b,0x361f,0x3623,0x2f81,0x3627,0x362b,0x3631,
+0x3635,0x3639,0x363d,0x2f89,0x3641,0x3645,0x3649,0x364d,0x3651,0x3655,0x3659,0x365d,0x2b65,0x309f,0x3661,0x3665,
+0x3669,0x366d,0x3673,0x3677,0x367b,0x367f,0x2f8d,0x3683,0x3689,0x368d,0x3691,0x3151,0x3695,0x3699,0x369d,0x36a1,
+0x36a5,0x36ab,0x36af,0x36b3,0x36b7,0x36bd,0x36c1,0x36c5,0x36c9,0x2c7d,0x36cd,0x36d1,0x36d7,0x36dd,0x36e3,0x36e7,
+0x36ed,0x36f1,0x36f5,0x36f9,0x36fd,0x2f91,0x2dd9,0x3701,0x3705,0x3709,0x370d,0x3713,0x3717,0x371b,0x371f,0x30af,
+0x3723,0x3727,0x372d,0x3731,0x3735,0x373b,0x3741,0x3745,0x30b3,0x3749,0x374d,0x3751,0x3755,0x3759,0x375d,0x3761,
+0x3767,0x376b,0x3771,0x3775,0x377b,0x30bb,0x377f,0x3783,0x3789,0x378d,0x3791,0x3797,0x379d,0x37a1,0x37a5,0x37a9,
+0x37ad,0x37ad,0x37b1,0x37b5,0x30c3,0x37b9,0x37bd,0x37c1,0x37c5,0x37c9,0x37cf,0x37d3,0x2c45,0x37d9,0x37df,0x37e3,
+0x37e9,0x37ef,0x37f5,0x37f9,0x30db,0x37fd,0x3803,0x3809,0x380f,0x3815,0x3819,0x3819,0x30df,0x3159,0x381d,0x3821,
+0x3825,0x3829,0x382f,0x2bad,0x30e7,0x3833,0x3837,0x2fbd,0x383d,0x3843,0x2f05,0x3849,0x384d,0x2fcd,0x3851,0x3855,
+0x3859,0x385f,0x385f,0x3865,0x3869,0x386d,0x3873,0x3877,0x387b,0x387f,0x3885,0x3889,0x388d,0x3891,0x3895,0x3899,
+0x389f,0x38a3,0x38a7,0x38ab,0x38af,0x38b3,0x38b7,0x38bd,0x38c3,0x38c7,0x38cd,0x38d1,0x38d7,0x38db,0x2fe5,0x38df,
+0x38e5,0x38eb,0x38ef,0x38f5,0x38f9,0x38ff,0x3903,0x3907,0x390b,0x390f,0x3913,0x3917,0x391d,0x3923,0x3929,0x3565,
+0x392f,0x3933,0x3937,0x393b,0x393f,0x3943,0x3947,0x394b,0x394f,0x3953,0x3957,0x395b,0x2c8d,0x3961,0x3965,0x3969,
+0x396d,0x3971,0x3975,0x2ff1,0x3979,0x397d,0x3981,0x3985,0x3989,0x398f,0x3995,0x399b,0x399f,0x39a3,0x39a7,0x39ab,
+0x39b1,0x39b5,0x39bb,0x39bf,0x39c3,0x39c9,0x39cf,0x39d3,0x2b99,0x39d7,0x39db,0x39df,0x39e3,0x39e7,0x39eb,0x3103,
+0x39ef,0x39f3,0x39f7,0x39fb,0x39ff,0x3a03,0x3a07,0x3a0b,0x3a0f,0x3a13,0x3a19,0x3a1d,0x3a21,0x3a25,0x3a29,0x3a2d,
+0x3a33,0x3a39,0x3a3d,0x3a41,0x3117,0x311b,0x3a45,0x3a49,0x3a4f,0x3a53,0x3a57,0x3a5b,0x3a5f,0x3a65,0x3a6b,0x3a6f,
+0x3a73,0x3a77,0x3a7d,0x311f,0x3a81,0x3a87,0x3a8d,0x3a91,0x3a95,0x3a99,0x3a9f,0x3aa3,0x3aa7,0x3aab,0x3aaf,0x3ab3,
+0x3ab7,0x3abb,0x3ac1,0x3ac5,0x3ac9,0x3acd,0x3ad3,0x3ad7,0x3adb,0x3adf,0x3ae3,0x3ae9,0x3aef,0x3af3,0x3af7,0x3afb,
+0x3b01,0x3b05,0x3137,0x3137,0x3b0b,0x3b0f,0x3b15,0x3b19,0x3b1d,0x3b21,0x3b25,0x3b29,0x3b2d,0x3b31,0x313b,0x3b37,
+0x3b3b,0x3b3f,0x3b43,0x3b47,0x3b4b,0x3b51,0x3b55,0x3b5b,0x3b61,0x3b67,0x3b6b,0x3b6f,0x3b73,0x3b77,0x3b7b,0x3b7f,
+0x3b83,0x3b87,1,1,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,1,1,1,1,1,1,
+1,1,1,1,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,
+0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,0xfe00,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0xadc,0x1283,0x1283,0x1283,
 0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
-0x1283,0x1283,0x1283,0x1283,0x3c54,1,0x3c54,1,0x3c54,0x3c54,0x3c54,0x3c54,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x3c54,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x3c54,
-1,1,1,1,0x3c54,1,1,1,0x3c54,1,0x3c54,1,1,1,1,1,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x1283,0x1283,0x1283,0x1283,
+0xadc,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,
+0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x1283,0x3c54,1,0x3c54,0x3c54,
+0x3c54,0x3c54,0x3c54,0x3c54,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x3c54,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,0x3c54,1,1,1,1,0x3c54,1,1,1,
+0x3c54,1,0x3c54,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x3b87,1,1,1,1,1
+1,1,0x3b87,1,1,1,1,1
 };
 
 static const uint16_t norm2_nfc_data_extraData[7724]={
@@ -1120,7 +1133,7 @@ static const uint16_t norm2_nfc_data_extraData[7724]={
 };
 
 static const uint8_t norm2_nfc_data_smallFCD[256]={
-0xc0,0xef,3,0x7f,0xdf,0x70,0xcf,0x87,0xc7,0x66,0x66,0x46,0x64,0x46,0x66,0x5b,
+0xc0,0xef,3,0x7f,0xdf,0x70,0xcf,0x87,0xc7,0xe6,0x66,0x46,0x64,0x46,0x66,0x5b,
 0x12,0,0,4,0,0,0,0x43,0x20,2,0x29,0xae,0xc2,0xc0,0xff,0xff,
 0xc0,0x72,0xbf,0,0,0,0,0,0,0,0x40,0,0x80,0x88,0,0,
 0xfe,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -1140,16 +1153,16 @@ static const uint8_t norm2_nfc_data_smallFCD[256]={
 
 static const UTrie2 norm2_nfc_data_trie={
     norm2_nfc_data_trieIndex,
-    norm2_nfc_data_trieIndex+2720,
+    norm2_nfc_data_trieIndex+2728,
     NULL,
-    2720,
-    7056,
+    2728,
+    7248,
     0x188,
-    0xb1c,
+    0xb24,
     0x1,
     0x1,
     0x30000,
-    0x262c,
+    0x26f4,
     NULL, 0, FALSE, FALSE, 0, NULL
 };
 
diff --git a/deps/icu-small/source/common/propname_data.h b/deps/icu-small/source/common/propname_data.h
index 5876fc7073aeb5..afa876c0fa8275 100644
--- a/deps/icu-small/source/common/propname_data.h
+++ b/deps/icu-small/source/common/propname_data.h
@@ -13,91 +13,93 @@
 
 U_NAMESPACE_BEGIN
 
-const int32_t PropNameData::indexes[8]={0x20,0x13c8,0x4831,0x92bb,0x92bb,0x92bb,0x2f,0};
+const int32_t PropNameData::indexes[8]={0x20,0x1424,0x49e9,0x966c,0x966c,0x966c,0x2f,0};
 
-const int32_t PropNameData::valueMaps[1258]={
-6,0,0x40,0,0xdb,0x356,0xdb,0x36c,0xdb,0x381,0xdb,0x397,0xdb,0x3a2,0xdb,0x3c3,
-0xdb,0x3d3,0xdb,0x3e2,0xdb,0x3f0,0xdb,0x414,0xdb,0x42b,0xdb,0x443,0xdb,0x45a,0xdb,0x469,
-0xdb,0x478,0xdb,0x489,0xdb,0x497,0xdb,0x4a9,0xdb,0x4c3,0xdb,0x4de,0xdb,0x4f3,0xdb,0x510,
-0xdb,0x521,0xdb,0x52c,0xdb,0x54b,0xdb,0x561,0xdb,0x572,0xdb,0x582,0xdb,0x59d,0xdb,0x5b6,
-0xdb,0x5c7,0xdb,0x5e1,0xdb,0x5f4,0xdb,0x604,0xdb,0x61e,0xdb,0x637,0xdb,0x64e,0xdb,0x662,
-0xdb,0x678,0xdb,0x68c,0xdb,0x6a2,0xdb,0x6bc,0xdb,0x6d4,0xdb,0x6f0,0xdb,0x6f8,0xdb,0x700,
-0xdb,0x708,0xdb,0x710,0xdb,0x719,0xdb,0x726,0xdb,0x739,0xdb,0x756,0xdb,0x773,0xdb,0x790,
-0xdb,0x7ae,0xdb,0x7cc,0xdb,0x7f0,0xdb,0x7fd,0xdb,0x824,0xdb,0x843,0xdb,0x86c,0xdb,0x88d,
-0xdb,0x8a4,0xdb,0x1000,0x1016,0x8c6,0x155,0xae6,0x170,0x2b81,0xe1,0x2ba0,0x28d,0x2cde,0x2a3,0x2d38,
-0x2ad,0x2f95,0x2cf,0x3836,0x337,0x38a6,0x341,0x3b40,0x370,0x3b7e,0x378,0x4567,0x42e,0x45e5,0x438,0x460a,
-0x43e,0x4624,0x444,0x4645,0x44b,0x465f,0xe1,0x4684,0xe1,0x46aa,0x452,0x4754,0x468,0x47cd,0x47b,0x486a,
-0x495,0x2000,0x2001,0x48a1,0x49c,0x3000,0x3001,0x492d,0,0x4000,0x400e,0x493f,0,0x4948,0,0x4962,
-0,0x4973,0,0x4984,0,0x499a,0,0x49a3,0,0x49c0,0,0x49de,0,0x49fc,0,0x4a1a,
-0,0x4a30,0,0x4a44,0,0x4a5a,0,0x7000,0x7001,0x4a73,0,0x748,0x12,0,1,0x12,
-0x20,0x766,0x49,0,1,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf,0x10,0x11,
-0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,
-0x22,0x23,0x24,0x54,0x5b,0x67,0x6b,0x76,0x7a,0x81,0x82,0x84,0x85,0xc8,0xca,0xd6,
-0xd8,0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xe9,0xea,0xf0,0x2e,0x40,0x4c,0x56,
-0x67,0x72,0x7f,0x8c,0x99,0xa6,0xb3,0xc0,0xcd,0xda,0xe7,0xf4,0x101,0x10e,0x11b,0x128,
-0x135,0x142,0x14f,0x15c,0x169,0x176,0x183,0x190,0x19d,0x1aa,0x1b7,0x1c4,0x1d1,0x1de,0x1eb,0x1fa,
-0x209,0x218,0x227,0x236,0x245,0x254,0x263,0x27d,0x291,0x2a5,0x2c0,0x2cf,0x2d8,0x2e8,0x2f0,0x2f9,
-0x308,0x311,0x321,0x332,0x343,0x8f8,1,0,0x17,0x8d5,0x8e6,0x8f7,0x90b,0x922,0x93a,0x94c,
-0x961,0x978,0x98d,0x99d,0x9af,0x9cc,0x9e8,0x9fa,0xa17,0xa33,0xa4f,0xa64,0xa79,0xa93,0xaae,0xac9,
-0xa9a,1,0,0x119,0xaf1,0xafe,0xb11,0xb39,0xb57,0xb75,0xb8d,0xbb8,0xbe2,0xbfa,0xc0d,0xc20,
-0xc2f,0xc3e,0xc4d,0xc5c,0xc73,0xc84,0xc97,0xcaa,0xcb7,0xcc4,0xcd3,0xce4,0xcf9,0xd0a,0xd15,0xd1e,
-0xd2f,0xd40,0xd53,0xd65,0xd78,0xd8b,0xdca,0xdd7,0xde4,0xdf1,0xe06,0xe36,0xe50,0xe71,0xe9c,0xebf,
-0xf1d,0xf44,0xf5f,0xf6e,0xf95,0xfbd,0xfe0,0x1003,0x102d,0x1046,0x1065,0x1088,0x10ac,0x10bf,0x10d9,0x1103,
-0x111b,0x1143,0x116c,0x117f,0x1192,0x11a5,0x11cc,0x11db,0x11fb,0x1229,0x1247,0x1275,0x1291,0x12ac,0x12c5,0x12de,
-0x12ff,0x132f,0x134e,0x1370,0x13a4,0x13d1,0x1416,0x1437,0x1461,0x1482,0x14ab,0x14be,0x14f1,0x1508,0x1517,0x1528,
-0x1553,0x156a,0x159b,0x15c9,0x160c,0x1617,0x1650,0x1661,0x1672,0x167f,0x1692,0x16cc,0x16f0,0x1714,0x174e,0x1786,
-0x17b1,0x17c9,0x17f5,0x1821,0x182e,0x183d,0x185a,0x187c,0x18aa,0x18ca,0x18f1,0x1918,0x1937,0x194a,0x195b,0x196c,
-0x1991,0x19b6,0x19dd,0x1a11,0x1a3e,0x1a5c,0x1a6f,0x1a88,0x1ac1,0x1ad0,0x1af0,0x1b12,0x1b34,0x1b4b,0x1b62,0x1b8f,
-0x1ba8,0x1bc1,0x1bf2,0x1c1c,0x1c37,0x1c4a,0x1c69,0x1c72,0x1c85,0x1ca3,0x1cc1,0x1cd4,0x1ceb,0x1d00,0x1d35,0x1d59,
-0x1d6e,0x1d7d,0x1d90,0x1db4,0x1dbd,0x1de1,0x1df8,0x1e0b,0x1e1a,0x1e25,0x1e46,0x1e5e,0x1e6d,0x1e7c,0x1e8b,0x1ea2,
-0x1eb7,0x1ecc,0x1f05,0x1f18,0x1f34,0x1f3f,0x1f4c,0x1f7a,0x1f9e,0x1fc1,0x1fd4,0x1ff6,0x2009,0x2024,0x2047,0x206a,
-0x208f,0x20a0,0x20cf,0x20fc,0x2113,0x212e,0x213d,0x2168,0x21a0,0x21da,0x2208,0x2219,0x2226,0x224a,0x2259,0x2275,
-0x228f,0x22ac,0x22e4,0x22f9,0x2326,0x2345,0x2373,0x2393,0x23c7,0x23d6,0x2400,0x2423,0x244e,0x2459,0x246a,0x2485,
-0x24a9,0x24b6,0x24cb,0x24f2,0x251d,0x2554,0x2567,0x2578,0x25a8,0x25b9,0x25c8,0x25dd,0x25fb,0x260e,0x2621,0x2638,
-0x2655,0x2660,0x2669,0x268b,0x26a0,0x26c5,0x26dc,0x2705,0x2720,0x2735,0x274e,0x276f,0x27a4,0x27b5,0x27e6,0x280a,
-0x281b,0x2834,0x283f,0x286c,0x288e,0x28bc,0x28ef,0x28fe,0x290f,0x292c,0x296e,0x2995,0x29a2,0x29b7,0x29db,0x2a01,
-0x2a3a,0x2a4b,0x2a6f,0x2a7a,0x2a87,0x2a96,0x2abb,0x2ae9,0x2b05,0x2b22,0x2b2f,0x2b40,0x2b5e,0x1c30,1,0,
-0x12,0x2bb7,0x2bc7,0x2bda,0x2bea,0x2bfa,0x2c09,0x2c19,0x2c2b,0x2c3e,0x2c50,0x2c60,0x2c70,0x2c7f,0x2c8e,0x2c9e,
-0x2cab,0x2cba,0x2cce,0x1cee,1,0,6,0x2cf3,0x2cfe,0x2d0b,0x2d18,0x2d25,0x2d30,0x1d32,1,0,
-0x1e,0x2d4d,0x2d5c,0x2d71,0x2d86,0x2d9b,0x2daf,0x2dc0,0x2dd4,0x2de7,0x2df8,0x2e11,0x2e23,0x2e34,0x2e48,0x2e5b,
-0x2e73,0x2e85,0x2e90,0x2ea0,0x2eae,0x2ec3,0x2ed8,0x2eee,0x2f08,0x2f1e,0x2f2e,0x2f42,0x2f56,0x2f67,0x2f7f,0x1f5d,
-1,0,0x64,0x2fa7,0x2fca,0x2fd3,0x2fe0,0x2feb,0x2ff4,0x2fff,0x3008,0x3021,0x3026,0x302f,0x304c,0x3055,
-0x3062,0x306b,0x308f,0x3096,0x309f,0x30b2,0x30bd,0x30c6,0x30d1,0x30ea,0x30f3,0x3102,0x310d,0x3116,0x3121,0x312a,
-0x3131,0x313a,0x3145,0x314e,0x3167,0x3170,0x317d,0x3188,0x3199,0x31a4,0x31b9,0x31d0,0x31d9,0x31e2,0x31fb,0x3206,
-0x320f,0x3218,0x322f,0x324c,0x3257,0x3268,0x3273,0x327a,0x3287,0x3294,0x32c1,0x32d6,0x32df,0x32fa,0x331d,0x333e,
-0x335f,0x3384,0x33ab,0x33cc,0x33ef,0x3410,0x3437,0x3458,0x347d,0x349c,0x34bb,0x34da,0x34f7,0x3518,0x3539,0x355c,
-0x3581,0x35a0,0x35bf,0x35e0,0x3607,0x362c,0x364b,0x366c,0x368f,0x36aa,0x36c3,0x36de,0x36f7,0x3714,0x372f,0x374c,
-0x376b,0x3788,0x37a5,0x37c4,0x37e1,0x37fc,0x3819,0x2283,1,0,6,0x3847,0x3856,0x3866,0x3876,0x3886,
-0x3897,0x22e1,1,0,0x2b,0x38b5,0x38c1,0x38cf,0x38de,0x38ed,0x38fd,0x390e,0x3922,0x3937,0x394d,0x3960,
-0x3974,0x3984,0x398d,0x3998,0x39a8,0x39c4,0x39d6,0x39e4,0x39f3,0x39ff,0x3a14,0x3a28,0x3a3b,0x3a49,0x3a5d,0x3a6b,
-0x3a75,0x3a87,0x3a93,0x3aa1,0x3ab1,0x3ab8,0x3abf,0x3ac6,0x3acd,0x3ad4,0x3aea,0x3b0b,0x88d,0x3b1d,0x3b28,0x3b37,
-0x253a,1,0,4,0x3b51,0x3b5c,0x3b68,0x3b72,0x2560,1,0,0xb2,0x3b89,0x3b96,0x3bab,0x3bb8,
-0x3bc7,0x3bd5,0x3be4,0x3bf3,0x3c05,0x3c14,0x3c22,0x3c33,0x3c42,0x3c51,0x3c5e,0x3c6a,0x3c79,0x3c88,0x3c92,0x3c9f,
-0x3cac,0x3cbb,0x3cc9,0x3cd8,0x3ce4,0x3cee,0x3cfa,0x3d0a,0x3d1a,0x3d28,0x3d34,0x3d45,0x3d51,0x3d5d,0x3d6b,0x3d78,
-0x3d84,0x3d91,0xd0a,0x3d9e,0x3dac,0x3dc6,0x3dcf,0x3ddd,0x3deb,0x3df7,0x3e06,0x3e14,0x3e22,0x3e2e,0x3e3d,0x3e4b,
-0x3e59,0x3e66,0x3e75,0x3e90,0x3e9f,0x3eb0,0x3ec1,0x3ed4,0x3ee6,0x3ef5,0x3f07,0x3f16,0x3f22,0x3f2d,0x1e1a,0x3f3a,
-0x3f45,0x3f50,0x3f5b,0x3f66,0x3f81,0x3f8c,0x3f97,0x3fa2,0x3fb5,0x3fc9,0x3fd4,0x3fe3,0x3ff2,0x3ffd,0x4008,0x4015,
-0x4024,0x4032,0x403d,0x4058,0x4062,0x4073,0x4084,0x4093,0x40a4,0x40af,0x40ba,0x40c5,0x40d0,0x40db,0x40e6,0x40f1,
-0x40fb,0x4106,0x4116,0x4121,0x412f,0x413c,0x4147,0x4156,0x4163,0x4170,0x417f,0x418c,0x419d,0x41af,0x41bf,0x41ca,
-0x41dd,0x41f4,0x4202,0x420f,0x421a,0x4227,0x4238,0x4254,0x426a,0x4275,0x4292,0x42a2,0x42b1,0x42bc,0x42c7,0x1f34,
-0x42d3,0x42de,0x42f6,0x4306,0x4315,0x4323,0x4331,0x433c,0x4347,0x435b,0x4372,0x438a,0x439a,0x43aa,0x43ba,0x43cc,
-0x43d7,0x43e2,0x43ec,0x43f8,0x4406,0x4419,0x4425,0x4432,0x443d,0x4459,0x4466,0x4474,0x448d,0x2834,0x449c,0x2655,
-0x44a9,0x44b7,0x44c9,0x44d7,0x44e3,0x44f3,0x2a6f,0x4501,0x450d,0x4518,0x4523,0x452e,0x4542,0x4550,0x2e57,1,
-0,6,0x4581,0x4594,0x45a4,0x45b2,0x45c3,0x45d3,0x2eb3,0x12,0,1,0x45fd,0x4603,0x2ec0,0x12,
-0,1,0x45fd,0x4603,0x2ecd,1,0,3,0x45fd,0x4603,0x463c,0x2ee3,1,0,3,0x45fd,
-0x4603,0x463c,0x2ef9,1,0,0x12,0x46c6,0x46d0,0x46dc,0x46e3,0x46ee,0x46f3,0x46fa,0x4701,0x470a,0x470f,
-0x4714,0x4724,0x88d,0x3b1d,0x4730,0x3b28,0x4740,0x3b37,0x2fa2,1,0,0xf,0x46c6,0x4767,0x4771,0x477b,
-0x4786,0x39f3,0x4790,0x479c,0x47a4,0x47ab,0x47b5,0x46dc,0x46e3,0x46f3,0x47bf,0x3029,1,0,0x16,0x46c6,
-0x47dc,0x477b,0x47e8,0x47f5,0x4803,0x39f3,0x480e,0x46dc,0x481f,0x46f3,0x482e,0x483c,0x88d,0x3b0b,0x4848,0x4859,
-0x3b1d,0x4730,0x3b28,0x4740,0x3b37,0x3139,1,0,3,0x4888,0x4890,0x4898,0x3152,0x36,1,2,
-4,8,0xe,0x10,0x20,0x3e,0x40,0x80,0x100,0x1c0,0x200,0x400,0x800,0xe00,0x1000,0x2000,
-0x4000,0x7000,0x8000,0x10000,0x20000,0x40000,0x78001,0x80000,0x100000,0x200000,0x400000,0x800000,0x1000000,0x2000000,0x4000000,0x8000000,
-0xf000000,0x10000000,0x20000000,0x30f80000,0x2d4d,0x2d5c,0x2d71,0x2d86,0x48cf,0x2d9b,0x2daf,0x48c5,0x2dc0,0x2dd4,0x2de7,0x48e0,
-0x2df8,0x2e11,0x2e23,0x48f7,0x2e34,0x2e48,0x2e5b,0x4920,0x2e73,0x2e85,0x2e90,0x2ea0,0x48bc,0x2eae,0x2ec3,0x2ed8,
-0x2eee,0x2f08,0x2f1e,0x2f2e,0x2f42,0x2f56,0x4916,0x2f67,0x2f7f,0x4901
+const int32_t PropNameData::valueMaps[1281]={
+6,0,0x41,0,0xdd,0x356,0xdd,0x36c,0xdd,0x381,0xdd,0x397,0xdd,0x3a2,0xdd,0x3c3,
+0xdd,0x3d3,0xdd,0x3e2,0xdd,0x3f0,0xdd,0x414,0xdd,0x42b,0xdd,0x443,0xdd,0x45a,0xdd,0x469,
+0xdd,0x478,0xdd,0x489,0xdd,0x497,0xdd,0x4a9,0xdd,0x4c3,0xdd,0x4de,0xdd,0x4f3,0xdd,0x510,
+0xdd,0x521,0xdd,0x52c,0xdd,0x54b,0xdd,0x561,0xdd,0x572,0xdd,0x582,0xdd,0x59d,0xdd,0x5b6,
+0xdd,0x5c7,0xdd,0x5e1,0xdd,0x5f4,0xdd,0x604,0xdd,0x61e,0xdd,0x637,0xdd,0x64e,0xdd,0x662,
+0xdd,0x678,0xdd,0x68c,0xdd,0x6a2,0xdd,0x6bc,0xdd,0x6d4,0xdd,0x6f0,0xdd,0x6f8,0xdd,0x700,
+0xdd,0x708,0xdd,0x710,0xdd,0x719,0xdd,0x726,0xdd,0x739,0xdd,0x756,0xdd,0x773,0xdd,0x790,
+0xdd,0x7ae,0xdd,0x7cc,0xdd,0x7f0,0xdd,0x7fd,0xdd,0x817,0xdd,0x82c,0xdd,0x847,0xdd,0x85e,
+0xdd,0x875,0xdd,0x897,0xdd,0x1000,0x1016,0x8b6,0x157,0xad6,0x172,0x2c95,0xe3,0x2cb4,0x29a,0x2df2,
+0x2b0,0x2e4c,0x2ba,0x30a9,0x2dc,0x39a4,0x346,0x3a14,0x350,0x3cae,0x37f,0x3cec,0x387,0x474b,0x444,0x47c9,
+0x44e,0x47ee,0x454,0x4808,0x45a,0x4829,0x461,0x4843,0xe3,0x4868,0xe3,0x488e,0x468,0x4938,0x47e,0x49b1,
+0x491,0x4a63,0x4ac,0x2000,0x2001,0x4a9a,0x4b3,0x3000,0x3001,0x4b26,0,0x4000,0x400e,0x4b38,0,0x4b41,
+0,0x4b5b,0,0x4b6c,0,0x4b7d,0,0x4b93,0,0x4b9c,0,0x4bb9,0,0x4bd7,0,0x4bf5,
+0,0x4c13,0,0x4c29,0,0x4c3d,0,0x4c53,0,0x7000,0x7001,0x4c6c,0,0x77c,0x12,0,
+1,0x12,0x20,0x79a,0x49,0,1,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf,
+0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
+0x20,0x21,0x22,0x23,0x24,0x54,0x5b,0x67,0x6b,0x76,0x7a,0x81,0x82,0x84,0x85,0xc8,
+0xca,0xd6,0xd8,0xda,0xdc,0xde,0xe0,0xe2,0xe4,0xe6,0xe8,0xe9,0xea,0xf0,0x2e,0x40,
+0x4c,0x56,0x67,0x72,0x7f,0x8c,0x99,0xa6,0xb3,0xc0,0xcd,0xda,0xe7,0xf4,0x101,0x10e,
+0x11b,0x128,0x135,0x142,0x14f,0x15c,0x169,0x176,0x183,0x190,0x19d,0x1aa,0x1b7,0x1c4,0x1d1,0x1de,
+0x1eb,0x1fa,0x209,0x218,0x227,0x236,0x245,0x254,0x263,0x27d,0x291,0x2a5,0x2c0,0x2cf,0x2d8,0x2e8,
+0x2f0,0x2f9,0x308,0x311,0x321,0x332,0x343,0x92c,1,0,0x17,0x8c5,0x8d6,0x8e7,0x8fb,0x912,
+0x92a,0x93c,0x951,0x968,0x97d,0x98d,0x99f,0x9bc,0x9d8,0x9ea,0xa07,0xa23,0xa3f,0xa54,0xa69,0xa83,
+0xa9e,0xab9,0xace,1,0,0x124,0xae1,0xaee,0xb01,0xb29,0xb47,0xb65,0xb7d,0xba8,0xbd2,0xbea,
+0xbfd,0xc10,0xc1f,0xc2e,0xc3d,0xc4c,0xc63,0xc74,0xc87,0xc9a,0xca7,0xcb4,0xcc3,0xcd4,0xce9,0xcfa,
+0xd05,0xd0e,0xd1f,0xd30,0xd43,0xd55,0xd68,0xd7b,0xdba,0xdc7,0xdd4,0xde1,0xdf6,0xe26,0xe40,0xe61,
+0xe8c,0xeaf,0xf0d,0xf34,0xf4f,0xf5e,0xf85,0xfad,0xfd0,0xff3,0x101d,0x1036,0x1055,0x1078,0x109c,0x10af,
+0x10c9,0x10f3,0x110b,0x1133,0x115c,0x116f,0x1182,0x1195,0x11bc,0x11cb,0x11eb,0x1219,0x1237,0x1265,0x1281,0x129c,
+0x12b5,0x12ce,0x12ef,0x131f,0x133e,0x1360,0x1394,0x13c1,0x1406,0x1427,0x1451,0x1472,0x149b,0x14ae,0x14e1,0x14f8,
+0x1507,0x1518,0x1543,0x155a,0x158b,0x15b9,0x15fc,0x1607,0x1640,0x1651,0x1662,0x166f,0x1682,0x16bc,0x16e0,0x1704,
+0x173e,0x1776,0x17a1,0x17b9,0x17e5,0x1811,0x181e,0x182d,0x184a,0x186c,0x189a,0x18ba,0x18e1,0x1908,0x1927,0x193a,
+0x194b,0x195c,0x1981,0x19a6,0x19cd,0x1a01,0x1a2e,0x1a4c,0x1a5f,0x1a78,0x1ab1,0x1ac0,0x1ae0,0x1b02,0x1b24,0x1b3b,
+0x1b52,0x1b7f,0x1b98,0x1bb1,0x1be2,0x1c0c,0x1c27,0x1c3a,0x1c59,0x1c62,0x1c75,0x1c93,0x1cb1,0x1cc4,0x1cdb,0x1cf0,
+0x1d25,0x1d49,0x1d5e,0x1d6d,0x1d80,0x1da4,0x1dad,0x1dd1,0x1de8,0x1dfb,0x1e0a,0x1e15,0x1e36,0x1e4e,0x1e5d,0x1e6c,
+0x1e7b,0x1e92,0x1ea7,0x1ebc,0x1ef5,0x1f08,0x1f24,0x1f2f,0x1f3c,0x1f6a,0x1f8e,0x1fb1,0x1fc4,0x1fe6,0x1ff9,0x2014,
+0x2037,0x205a,0x207f,0x2090,0x20bf,0x20ec,0x2103,0x211e,0x212d,0x2158,0x2190,0x21ca,0x21f8,0x2209,0x2216,0x223a,
+0x2249,0x2265,0x227f,0x229c,0x22d4,0x22e9,0x2316,0x2335,0x2363,0x2383,0x23b7,0x23c6,0x23f0,0x2413,0x243e,0x2449,
+0x245a,0x2475,0x2499,0x24a6,0x24bb,0x24e2,0x250d,0x2544,0x2557,0x2568,0x2598,0x25a9,0x25b8,0x25cd,0x25eb,0x25fe,
+0x2611,0x2628,0x2645,0x2650,0x2659,0x267b,0x2690,0x26b5,0x26cc,0x26f5,0x2710,0x2725,0x273e,0x275f,0x2794,0x27a5,
+0x27d6,0x27fa,0x280b,0x2824,0x282f,0x285c,0x287e,0x28ac,0x28df,0x28ee,0x28ff,0x291c,0x295e,0x2985,0x2992,0x29a7,
+0x29cb,0x29f1,0x2a2a,0x2a3b,0x2a5f,0x2a6a,0x2a77,0x2a86,0x2aab,0x2ad9,0x2af5,0x2b12,0x2b1f,0x2b30,0x2b4e,0x2b71,
+0x2b8e,0x2b9b,0x2bbb,0x2bd8,0x2bf9,0x2c22,0x2c33,0x2c52,0x2c6b,0x2c84,0x1cf4,1,0,0x12,0x2ccb,0x2cdb,
+0x2cee,0x2cfe,0x2d0e,0x2d1d,0x2d2d,0x2d3f,0x2d52,0x2d64,0x2d74,0x2d84,0x2d93,0x2da2,0x2db2,0x2dbf,0x2dce,0x2de2,
+0x1db2,1,0,6,0x2e07,0x2e12,0x2e1f,0x2e2c,0x2e39,0x2e44,0x1df6,1,0,0x1e,0x2e61,0x2e70,
+0x2e85,0x2e9a,0x2eaf,0x2ec3,0x2ed4,0x2ee8,0x2efb,0x2f0c,0x2f25,0x2f37,0x2f48,0x2f5c,0x2f6f,0x2f87,0x2f99,0x2fa4,
+0x2fb4,0x2fc2,0x2fd7,0x2fec,0x3002,0x301c,0x3032,0x3042,0x3056,0x306a,0x307b,0x3093,0x2021,1,0,0x66,
+0x30bb,0x30de,0x30e7,0x30f4,0x30ff,0x3108,0x3113,0x311c,0x3135,0x313a,0x3143,0x3160,0x3169,0x3176,0x317f,0x31a3,
+0x31aa,0x31b3,0x31c6,0x31d1,0x31da,0x31e5,0x31fe,0x3207,0x3216,0x3221,0x322a,0x3235,0x323e,0x3245,0x324e,0x3259,
+0x3262,0x327b,0x3284,0x3291,0x329c,0x32ad,0x32b8,0x32cd,0x32e4,0x32ed,0x32f6,0x330f,0x331a,0x3323,0x332c,0x3343,
+0x3360,0x336b,0x337c,0x3387,0x338e,0x339b,0x33a8,0x33d5,0x33ea,0x33f3,0x340e,0x3431,0x3452,0x3473,0x3498,0x34bf,
+0x34e0,0x3503,0x3524,0x354b,0x356c,0x3591,0x35b0,0x35cf,0x35ee,0x360b,0x362c,0x364d,0x3670,0x3695,0x36b4,0x36d3,
+0x36f4,0x371b,0x3740,0x375f,0x3780,0x37a3,0x37be,0x37d7,0x37f2,0x380b,0x3828,0x3843,0x3860,0x387f,0x389c,0x38b9,
+0x38d8,0x38f5,0x3910,0x392d,0x394a,0x397d,0x2366,1,0,6,0x39b5,0x39c4,0x39d4,0x39e4,0x39f4,0x3a05,
+0x23c4,1,0,0x2b,0x3a23,0x3a2f,0x3a3d,0x3a4c,0x3a5b,0x3a6b,0x3a7c,0x3a90,0x3aa5,0x3abb,0x3ace,0x3ae2,
+0x3af2,0x3afb,0x3b06,0x3b16,0x3b32,0x3b44,0x3b52,0x3b61,0x3b6d,0x3b82,0x3b96,0x3ba9,0x3bb7,0x3bcb,0x3bd9,0x3be3,
+0x3bf5,0x3c01,0x3c0f,0x3c1f,0x3c26,0x3c2d,0x3c34,0x3c3b,0x3c42,0x3c58,0x3c79,0x85e,0x3c8b,0x3c96,0x3ca5,0x261d,
+1,0,4,0x3cbf,0x3cca,0x3cd6,0x3ce0,0x2643,1,0,0xb9,0x3cf7,0x3d04,0x3d19,0x3d26,0x3d35,
+0x3d43,0x3d52,0x3d61,0x3d73,0x3d82,0x3d90,0x3da1,0x3db0,0x3dbf,0x3dcc,0x3dd8,0x3de7,0x3df6,0x3e00,0x3e0d,0x3e1a,
+0x3e29,0x3e37,0x3e46,0x3e52,0x3e5c,0x3e68,0x3e78,0x3e88,0x3e96,0x3ea2,0x3eb3,0x3ebf,0x3ecb,0x3ed9,0x3ee6,0x3ef2,
+0x3eff,0xcfa,0x3f0c,0x3f1a,0x3f34,0x3f3d,0x3f4b,0x3f59,0x3f65,0x3f74,0x3f82,0x3f90,0x3f9c,0x3fab,0x3fb9,0x3fc7,
+0x3fd4,0x3fe3,0x3ffe,0x400d,0x401e,0x402f,0x4042,0x4054,0x4063,0x4075,0x4084,0x4090,0x409b,0x1e0a,0x40a8,0x40b3,
+0x40be,0x40c9,0x40d4,0x40ef,0x40fa,0x4105,0x4110,0x4123,0x4137,0x4142,0x4151,0x4160,0x416b,0x4176,0x4183,0x4192,
+0x41a0,0x41ab,0x41c6,0x41d0,0x41e1,0x41f2,0x4201,0x4212,0x421d,0x4228,0x4233,0x423e,0x4249,0x4254,0x425f,0x4269,
+0x4274,0x4284,0x428f,0x429d,0x42aa,0x42b5,0x42c4,0x42d1,0x42de,0x42ed,0x42fa,0x430b,0x431d,0x432d,0x4338,0x434b,
+0x4362,0x4370,0x437d,0x4388,0x4395,0x43a6,0x43c2,0x43d8,0x43e3,0x4400,0x4410,0x441f,0x442a,0x4435,0x1f24,0x4441,
+0x444c,0x4464,0x4474,0x4483,0x4491,0x449f,0x44aa,0x44b5,0x44c9,0x44e0,0x44f8,0x4508,0x4518,0x4528,0x453a,0x4545,
+0x4550,0x455a,0x4566,0x4574,0x4587,0x4593,0x45a0,0x45ab,0x45c7,0x45d4,0x45e2,0x45fb,0x2824,0x460a,0x2645,0x4617,
+0x4625,0x4637,0x4645,0x4651,0x4661,0x2a5f,0x466f,0x467b,0x4686,0x4691,0x469c,0x46b0,0x46be,0x46d5,0x46e1,0x46f5,
+0x4703,0x4715,0x472b,0x4739,0x2fa6,1,0,6,0x4765,0x4778,0x4788,0x4796,0x47a7,0x47b7,0x3002,0x12,
+0,1,0x47e1,0x47e7,0x300f,0x12,0,1,0x47e1,0x47e7,0x301c,1,0,3,0x47e1,0x47e7,
+0x4820,0x3032,1,0,3,0x47e1,0x47e7,0x4820,0x3048,1,0,0x12,0x48aa,0x48b4,0x48c0,0x48c7,
+0x48d2,0x48d7,0x48de,0x48e5,0x48ee,0x48f3,0x48f8,0x4908,0x85e,0x3c8b,0x4914,0x3c96,0x4924,0x3ca5,0x30f1,1,
+0,0xf,0x48aa,0x494b,0x4955,0x495f,0x496a,0x3b61,0x4974,0x4980,0x4988,0x498f,0x4999,0x48c0,0x48c7,0x48d7,
+0x49a3,0x3178,1,0,0x17,0x48aa,0x49c0,0x495f,0x49cc,0x49d9,0x49e7,0x3b61,0x49f2,0x48c0,0x4a03,0x48d7,
+0x4a12,0x4a20,0x85e,0x3c79,0x4a2c,0x4a3d,0x3c8b,0x4914,0x3c96,0x4924,0x3ca5,0x4a4e,0x3295,1,0,3,
+0x4a81,0x4a89,0x4a91,0x32ae,0x36,1,2,4,8,0xe,0x10,0x20,0x3e,0x40,0x80,0x100,
+0x1c0,0x200,0x400,0x800,0xe00,0x1000,0x2000,0x4000,0x7000,0x8000,0x10000,0x20000,0x40000,0x78001,0x80000,0x100000,
+0x200000,0x400000,0x800000,0x1000000,0x2000000,0x4000000,0x8000000,0xf000000,0x10000000,0x20000000,0x30f80000,0x2e61,0x2e70,0x2e85,0x2e9a,0x4ac8,
+0x2eaf,0x2ec3,0x4abe,0x2ed4,0x2ee8,0x2efb,0x4ad9,0x2f0c,0x2f25,0x2f37,0x4af0,0x2f48,0x2f5c,0x2f6f,0x4b19,0x2f87,
+0x2f99,0x2fa4,0x2fb4,0x4ab5,0x2fc2,0x2fd7,0x2fec,0x3002,0x301c,0x3032,0x3042,0x3056,0x306a,0x4b0f,0x307b,0x3093,
+0x4afa
 };
 
-const uint8_t PropNameData::bytesTries[13417]={
+const uint8_t PropNameData::bytesTries[13765]={
 0,0x15,0x6d,0xc3,0x5d,0x73,0xc1,0xf7,0x76,0x5f,0x76,0x68,0x77,0x90,0x78,1,
 0x64,0x50,0x69,0x10,0x64,1,0x63,0x30,0x73,0x62,0x13,0x74,0x61,0x72,0x74,0x63,
 0x60,0x16,0x6f,0x6e,0x74,0x69,0x6e,0x75,0x65,0x61,0x13,0x69,0x67,0x69,0x74,0x81,
@@ -180,766 +182,788 @@ const uint8_t PropNameData::bytesTries[13417]={
 0x6e,0x64,0x37,0x12,0x61,0x73,0x65,0x35,0x11,0x78,0x74,0x37,0xc2,5,1,0x62,
 0xc3,0x12,0x6d,0xd9,0x20,0,0x1c,0x6e,0x65,0x72,0x61,0x6c,0x63,0x61,0x74,0x65,
 0x67,0x6f,0x72,0x79,0xc2,5,0x13,0x6d,0x61,0x73,0x6b,0xd9,0x20,0,0x61,0xa2,
-0x5c,0x62,0xa2,0x8a,0x63,0xa2,0xfc,0x64,0xa4,0xc9,0x65,2,0x61,0x3a,0x6d,0x58,
-0x78,0x10,0x74,0x30,0x14,0x65,0x6e,0x64,0x65,0x72,0x31,0xc2,4,0x1b,0x73,0x74,
-0x61,0x73,0x69,0x61,0x6e,0x77,0x69,0x64,0x74,0x68,0xc3,4,0x12,0x6f,0x6a,0x69,
-0x92,2,0x63,0x40,0x6d,0x50,0x70,0x1a,0x72,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,
-0x69,0x6f,0x6e,0x95,0x17,0x6f,0x6d,0x70,0x6f,0x6e,0x65,0x6e,0x74,0x9b,0x16,0x6f,
-0x64,0x69,0x66,0x69,0x65,0x72,0x96,0x13,0x62,0x61,0x73,0x65,0x99,3,0x67,0x44,
-0x68,0x4a,0x6c,0x4e,0x73,0x1a,0x63,0x69,0x69,0x68,0x65,0x78,0x64,0x69,0x67,0x69,
-0x74,0x23,0x10,0x65,0xd9,0x40,0,0x11,0x65,0x78,0x23,1,0x6e,0x38,0x70,0x11,
-0x68,0x61,0x20,0x14,0x62,0x65,0x74,0x69,0x63,0x21,0x11,0x75,0x6d,0x79,4,0x63,
-0xc3,0,0x69,0x3e,0x6c,0xa2,0x57,0x6d,0xa2,0x64,0x70,1,0x62,0xd9,0x40,0xd,
-0x74,0xc3,0x15,0x11,0x64,0x69,2,0x63,0x54,0x6d,0x74,0x70,0x1b,0x61,0x69,0x72,
-0x65,0x64,0x62,0x72,0x61,0x63,0x6b,0x65,0x74,0xd8,0x40,0xd,0x13,0x74,0x79,0x70,
-0x65,0xc3,0x15,0x24,1,0x6c,0x30,0x6f,0x14,0x6e,0x74,0x72,0x6f,0x6c,0x25,0x12,
-0x61,0x73,0x73,0xc3,0,0x26,0x14,0x69,0x72,0x72,0x6f,0x72,1,0x65,0x38,0x69,
-0x16,0x6e,0x67,0x67,0x6c,0x79,0x70,0x68,0xd9,0x40,1,0x10,0x64,0x27,2,0x61,
-0x32,0x6b,0xc3,1,0x6f,0x11,0x63,0x6b,0xc3,1,0x11,0x6e,0x6b,0x7b,0x10,0x67,
-0xd9,0x40,1,6,0x68,0x7c,0x68,0x54,0x69,0x85,0x6f,0xa2,0x6f,0x77,4,0x63,
-0x30,0x6b,0x36,0x6c,0x87,0x74,0x8b,0x75,0x89,1,0x66,0x8d,0x6d,0x8f,0x11,0x63,
-0x66,0x91,0x18,0x61,0x6e,0x67,0x65,0x73,0x77,0x68,0x65,0x6e,4,0x63,0x44,0x6c,
-0x6c,0x6e,0x7e,0x74,0x98,0x75,0x18,0x70,0x70,0x65,0x72,0x63,0x61,0x73,0x65,0x64,
-0x89,0x12,0x61,0x73,0x65,1,0x66,0x30,0x6d,0x14,0x61,0x70,0x70,0x65,0x64,0x8f,
-0x14,0x6f,0x6c,0x64,0x65,0x64,0x8d,0x18,0x6f,0x77,0x65,0x72,0x63,0x61,0x73,0x65,
-0x64,0x87,0x1c,0x66,0x6b,0x63,0x63,0x61,0x73,0x65,0x66,0x6f,0x6c,0x64,0x65,0x64,
-0x91,0x18,0x69,0x74,0x6c,0x65,0x63,0x61,0x73,0x65,0x64,0x8b,0x13,0x6d,0x70,0x65,
-0x78,0x33,0x61,0x2e,0x63,0xa2,0x48,0x66,0xd9,0x40,2,1,0x6e,0x72,0x73,0x10,
-0x65,3,0x64,0x83,0x66,0x3a,0x69,0x4a,0x73,0x17,0x65,0x6e,0x73,0x69,0x74,0x69,
-0x76,0x65,0x65,0x15,0x6f,0x6c,0x64,0x69,0x6e,0x67,0xd9,0x40,2,0x17,0x67,0x6e,
-0x6f,0x72,0x61,0x62,0x6c,0x65,0x85,0x13,0x6f,0x6e,0x69,0x63,0x1f,0x61,0x6c,0x63,
-0x6f,0x6d,0x62,0x69,0x6e,0x69,0x6e,0x67,0x63,0x6c,0x61,0x73,0x73,0xc3,2,0x10,
-0x63,0xc3,2,3,0x61,0x30,0x65,0x34,0x69,0xa2,0x41,0x74,0xc3,3,0x11,0x73,
-0x68,0x29,2,0x63,0x3a,0x66,0x58,0x70,0x2c,0x16,0x72,0x65,0x63,0x61,0x74,0x65,
-0x64,0x2d,0x1d,0x6f,0x6d,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,0x6e,0x74,0x79,0x70,
-0x65,0xc3,3,0x15,0x61,0x75,0x6c,0x74,0x69,0x67,0x1f,0x6e,0x6f,0x72,0x61,0x62,
-0x6c,0x65,0x63,0x6f,0x64,0x65,0x70,0x6f,0x69,0x6e,0x74,0x2b,0x2a,0x10,0x61,0x2e,
-0x15,0x63,0x72,0x69,0x74,0x69,0x63,0x2f,3,0x66,0x34,0x6e,0x3e,0x74,0x42,0x79,
-0x22,0x11,0x65,0x73,0x23,0x20,0x13,0x61,0x6c,0x73,0x65,0x21,0x20,0x10,0x6f,0x21,
-0x22,0x12,0x72,0x75,0x65,0x23,0xa,0x6b,0x5b,0x6f,0x23,0x6f,0x3c,0x72,0x4c,0x76,
-1,0x69,0x24,0x72,0x33,0x13,0x72,0x61,0x6d,0x61,0x33,0x10,0x76,0x22,0x14,0x65,
-0x72,0x6c,0x61,0x79,0x23,0xa2,0xe2,0x13,0x69,0x67,0x68,0x74,0xa3,0xe2,0x6b,0x58,
-0x6c,0x74,0x6e,3,0x6b,0x2f,0x6f,0x30,0x72,0x21,0x75,0x12,0x6b,0x74,0x61,0x2f,
-0x19,0x74,0x72,0x65,0x6f,0x72,0x64,0x65,0x72,0x65,0x64,0x21,1,0x61,0x24,0x76,
-0x31,0x18,0x6e,0x61,0x76,0x6f,0x69,0x63,0x69,0x6e,0x67,0x31,0xa2,0xe0,0x12,0x65,
-0x66,0x74,0xa3,0xe0,0x61,0x5c,0x62,0xa2,0x77,0x63,0xa2,0x96,0x64,0xa4,0xa,0x69,
-1,0x6f,0x26,0x73,0xa3,0xf0,0x1a,0x74,0x61,0x73,0x75,0x62,0x73,0x63,0x72,0x69,
-0x70,0x74,0xa3,0xf0,0xa2,0xe6,3,0x62,0xa0,0x6c,0xa3,0xe4,0x72,0xa3,0xe8,0x74,
-2,0x61,0x74,0x62,0x7c,0x74,0x14,0x61,0x63,0x68,0x65,0x64,1,0x61,0x3e,0x62,
-0x13,0x65,0x6c,0x6f,0x77,0xa2,0xca,0x13,0x6c,0x65,0x66,0x74,0xa3,0xc8,0x13,0x62,
-0x6f,0x76,0x65,0xa2,0xd6,0x14,0x72,0x69,0x67,0x68,0x74,0xa3,0xd8,0xa2,0xd6,0x10,
-0x72,0xa3,0xd8,0xa2,0xca,0x10,0x6c,0xa3,0xc8,0x12,0x6f,0x76,0x65,0xa2,0xe6,1,
-0x6c,0x30,0x72,0x13,0x69,0x67,0x68,0x74,0xa3,0xe8,0x12,0x65,0x66,0x74,0xa3,0xe4,
-0xa2,0xdc,2,0x65,0x2c,0x6c,0xa3,0xda,0x72,0xa3,0xde,0x12,0x6c,0x6f,0x77,0xa2,
-0xdc,1,0x6c,0x30,0x72,0x13,0x69,0x67,0x68,0x74,0xa3,0xde,0x12,0x65,0x66,0x74,
-0xa3,0xda,0x11,0x63,0x63,4,0x31,0x3c,0x32,0xa2,0x42,0x33,0xa2,0x56,0x38,0xa2,
-0x64,0x39,0x10,0x31,0xa3,0x5b,9,0x35,0xa,0x35,0x3f,0x36,0x41,0x37,0x43,0x38,
-0x45,0x39,0x47,0x30,0x30,0x31,0x3c,0x32,0x42,0x33,0x4e,0x34,0x3d,0x34,1,0x33,
-0xa3,0x67,0x37,0xa3,0x6b,0x36,0x10,0x38,0xa3,0x76,0x38,1,0x32,0xa3,0x7a,0x39,
-0xa3,0x81,0x3a,2,0x30,0xa3,0x82,0x32,0xa3,0x84,0x33,0xa3,0x85,9,0x35,0xa,
-0x35,0x53,0x36,0x55,0x37,0x57,0x38,0x59,0x39,0x5b,0x30,0x49,0x31,0x4b,0x32,0x4d,
-0x33,0x4f,0x34,0x51,6,0x33,8,0x33,0x63,0x34,0x65,0x35,0x67,0x36,0x69,0x30,
-0x5d,0x31,0x5f,0x32,0x61,0x10,0x34,0xa3,0x54,2,0x61,0xa3,0xea,0x62,0xa3,0xe9,
-0x6f,0x13,0x75,0x62,0x6c,0x65,1,0x61,0x30,0x62,0x13,0x65,0x6c,0x6f,0x77,0xa3,
-0xe9,0x13,0x62,0x6f,0x76,0x65,0xa3,0xea,0xb,0x6e,0xc0,0xca,0x72,0x5f,0x72,0x46,
-0x73,0xa2,0x48,0x77,1,0x68,0x24,0x73,0x33,0x17,0x69,0x74,0x65,0x73,0x70,0x61,
-0x63,0x65,0x33,0x22,1,0x69,0x30,0x6c,2,0x65,0x3d,0x69,0x4b,0x6f,0x3f,0x18,
-0x67,0x68,0x74,0x74,0x6f,0x6c,0x65,0x66,0x74,0x22,2,0x65,0x38,0x69,0x48,0x6f,
-0x16,0x76,0x65,0x72,0x72,0x69,0x64,0x65,0x3f,0x17,0x6d,0x62,0x65,0x64,0x64,0x69,
-0x6e,0x67,0x3d,0x15,0x73,0x6f,0x6c,0x61,0x74,0x65,0x4b,0x30,0x1e,0x65,0x67,0x6d,
-0x65,0x6e,0x74,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x31,0x6e,0xa2,0x41,
-0x6f,0xa2,0x53,0x70,2,0x61,0x66,0x64,0x86,0x6f,0x1b,0x70,0x64,0x69,0x72,0x65,
-0x63,0x74,0x69,0x6f,0x6e,0x61,0x6c,1,0x66,0x32,0x69,0x15,0x73,0x6f,0x6c,0x61,
-0x74,0x65,0x4d,0x14,0x6f,0x72,0x6d,0x61,0x74,0x41,0x1f,0x72,0x61,0x67,0x72,0x61,
-0x70,0x68,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x2f,1,0x66,0x41,0x69,
-0x4d,1,0x6f,0x28,0x73,0x10,0x6d,0x43,0x1b,0x6e,0x73,0x70,0x61,0x63,0x69,0x6e,
-0x67,0x6d,0x61,0x72,0x6b,0x43,1,0x6e,0x35,0x74,0x19,0x68,0x65,0x72,0x6e,0x65,
-0x75,0x74,0x72,0x61,0x6c,0x35,0x65,0x88,0x65,0x98,0x66,0xa2,0x6a,0x6c,0x20,1,
-0x65,0x30,0x72,2,0x65,0x37,0x69,0x49,0x6f,0x39,0x18,0x66,0x74,0x74,0x6f,0x72,
-0x69,0x67,0x68,0x74,0x20,2,0x65,0x38,0x69,0x48,0x6f,0x16,0x76,0x65,0x72,0x72,
-0x69,0x64,0x65,0x39,0x17,0x6d,0x62,0x65,0x64,0x64,0x69,0x6e,0x67,0x37,0x15,0x73,
-0x6f,0x6c,0x61,0x74,0x65,0x49,3,0x6e,0x25,0x73,0x27,0x74,0x29,0x75,0x15,0x72,
-0x6f,0x70,0x65,0x61,0x6e,2,0x6e,0x3c,0x73,0x46,0x74,0x18,0x65,0x72,0x6d,0x69,
-0x6e,0x61,0x74,0x6f,0x72,0x29,0x14,0x75,0x6d,0x62,0x65,0x72,0x25,0x17,0x65,0x70,
-0x61,0x72,0x61,0x74,0x6f,0x72,0x27,1,0x69,0x28,0x73,0x10,0x69,0x47,0x1f,0x72,
-0x73,0x74,0x73,0x74,0x72,0x6f,0x6e,0x67,0x69,0x73,0x6f,0x6c,0x61,0x74,0x65,0x47,
-0x61,0x4e,0x62,0x84,0x63,1,0x6f,0x24,0x73,0x2d,0x1c,0x6d,0x6d,0x6f,0x6e,0x73,
-0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x2d,2,0x6c,0x3b,0x6e,0x2b,0x72,0x13,
-0x61,0x62,0x69,0x63,1,0x6c,0x30,0x6e,0x14,0x75,0x6d,0x62,0x65,0x72,0x2b,0x14,
-0x65,0x74,0x74,0x65,0x72,0x3b,0x2e,1,0x6e,0x45,0x6f,0x1c,0x75,0x6e,0x64,0x61,
-0x72,0x79,0x6e,0x65,0x75,0x74,0x72,0x61,0x6c,0x45,0,0x16,0x6d,0xc7,0xc5,0x74,
-0xc1,0xb8,0x77,0x57,0x77,0x48,0x79,0x5c,0x7a,0x1d,0x61,0x6e,0x61,0x62,0x61,0x7a,
-0x61,0x72,0x73,0x71,0x75,0x61,0x72,0x65,0xa5,0x18,0x18,0x61,0x72,0x61,0x6e,0x67,
-0x63,0x69,0x74,0x69,0xa3,0xfc,0x10,0x69,2,0x6a,0x3c,0x72,0x68,0x73,0x17,0x79,
-0x6c,0x6c,0x61,0x62,0x6c,0x65,0x73,0xa3,0x48,0x12,0x69,0x6e,0x67,0xa2,0x74,0x1e,
-0x68,0x65,0x78,0x61,0x67,0x72,0x61,0x6d,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,
-0x74,0x16,0x61,0x64,0x69,0x63,0x61,0x6c,0x73,0xa3,0x49,0x74,0xa2,0x59,0x75,0xa4,
-0x12,0x76,2,0x61,0x36,0x65,0x7a,0x73,0xa2,0x6c,0x12,0x73,0x75,0x70,0xa3,0x7d,
-1,0x69,0xa3,0x9f,0x72,0x1e,0x69,0x61,0x74,0x69,0x6f,0x6e,0x73,0x65,0x6c,0x65,
-0x63,0x74,0x6f,0x72,0x73,0xa2,0x6c,0x19,0x73,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,
-0x6e,0x74,0xa3,0x7d,1,0x64,0x3c,0x72,0x19,0x74,0x69,0x63,0x61,0x6c,0x66,0x6f,
-0x72,0x6d,0x73,0xa3,0x91,0x14,0x69,0x63,0x65,0x78,0x74,0xa2,0xaf,0x16,0x65,0x6e,
-0x73,0x69,0x6f,0x6e,0x73,0xa3,0xaf,4,0x61,0x68,0x65,0xa2,0x8a,0x68,0xa2,0x8d,
-0x69,0xa2,0x95,0x72,0x1c,0x61,0x6e,0x73,0x70,0x6f,0x72,0x74,0x61,0x6e,0x64,0x6d,
-0x61,0x70,0xa2,0xcf,0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xcf,4,0x67,
-0x58,0x69,0x7e,0x6b,0xa2,0x58,0x6d,0xa2,0x5a,0x6e,0x12,0x67,0x75,0x74,0xa4,0x10,
-0x19,0x63,0x6f,0x6d,0x70,0x6f,0x6e,0x65,0x6e,0x74,0x73,0xa5,0x11,2,0x61,0x2a,
-0x62,0x32,0x73,0xa3,0x60,0x12,0x6c,0x6f,0x67,0xa3,0x62,0x13,0x61,0x6e,0x77,0x61,
-0xa3,0x65,3,0x6c,0x52,0x74,0x56,0x76,0x5e,0x78,0x16,0x75,0x61,0x6e,0x6a,0x69,
-0x6e,0x67,0xa2,0x7c,0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x7c,0x10,0x65,
-0xa3,0x70,0x12,0x68,0x61,0x6d,0xa3,0xae,0x12,0x69,0x65,0x74,0xa3,0xb7,0x11,0x72,
-0x69,0xa3,0xdc,0x11,0x69,0x6c,0x49,0x13,0x6c,0x75,0x67,0x75,0x4b,0x10,0x61,1,
-0x61,0x24,0x69,0x53,0x11,0x6e,0x61,0x3d,2,0x62,0x34,0x66,0x3c,0x72,0x13,0x68,
-0x75,0x74,0x61,0xa3,0xfb,0x13,0x65,0x74,0x61,0x6e,0x57,0x14,0x69,0x6e,0x61,0x67,
-0x68,0xa3,0x90,2,0x63,0x82,0x67,0x92,0x6e,0x1f,0x69,0x66,0x69,0x65,0x64,0x63,
-0x61,0x6e,0x61,0x64,0x69,0x61,0x6e,0x61,0x62,0x6f,0x1f,0x72,0x69,0x67,0x69,0x6e,
-0x61,0x6c,0x73,0x79,0x6c,0x6c,0x61,0x62,0x69,0x63,0x73,0x62,0x17,0x65,0x78,0x74,
-0x65,0x6e,0x64,0x65,0x64,0xa3,0xad,0x11,0x61,0x73,0x62,0x12,0x65,0x78,0x74,0xa3,
-0xad,0x15,0x61,0x72,0x69,0x74,0x69,0x63,0xa3,0x78,0x70,0xc2,0xeb,0x70,0xa6,1,
-0x72,0xa6,0xbd,0x73,7,0x6f,0xc1,0x75,0x6f,0x74,0x70,0x9c,0x75,0xa2,0x5d,0x79,
-1,0x6c,0x4c,0x72,0x12,0x69,0x61,0x63,0x3a,0x12,0x73,0x75,0x70,0xa4,0x17,0x16,
-0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa5,0x17,0x17,0x6f,0x74,0x69,0x6e,0x61,0x67,
-0x72,0x69,0xa3,0x8f,1,0x72,0x30,0x79,0x13,0x6f,0x6d,0x62,0x6f,0xa5,0x16,0x17,
-0x61,0x73,0x6f,0x6d,0x70,0x65,0x6e,0x67,0xa3,0xda,1,0x61,0x32,0x65,0x14,0x63,
-0x69,0x61,0x6c,0x73,0xa3,0x56,0x12,0x63,0x69,0x6e,0x1f,0x67,0x6d,0x6f,0x64,0x69,
-0x66,0x69,0x65,0x72,0x6c,0x65,0x74,0x74,0x65,0x72,0x73,0x2d,2,0x6e,0x48,0x70,
-0x76,0x74,0x1d,0x74,0x6f,0x6e,0x73,0x69,0x67,0x6e,0x77,0x72,0x69,0x74,0x69,0x6e,
-0x67,0xa5,6,0x15,0x64,0x61,0x6e,0x65,0x73,0x65,0xa2,0x9b,0x12,0x73,0x75,0x70,
-0xa2,0xdb,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xdb,4,0x61,0xa2,0xa8,
-0x65,0x5c,0x6d,0x9e,0x70,0xa2,0x4b,0x73,0x13,0x79,0x6d,0x62,0x6f,0x1f,0x6c,0x73,
-0x61,0x6e,0x64,0x70,0x69,0x63,0x74,0x6f,0x67,0x72,0x61,0x70,0x68,0x73,0xa5,5,
-0x10,0x72,1,0x61,0x4e,0x73,0x12,0x63,0x72,0x69,0x1f,0x70,0x74,0x73,0x61,0x6e,
-0x64,0x73,0x75,0x62,0x73,0x63,0x72,0x69,0x70,0x74,0x73,0x73,0x14,0x6e,0x64,0x73,
-0x75,0x62,0x73,0x1b,0x61,0x74,0x68,0x6f,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,
-0xa3,0x6a,1,0x6c,0x40,0x75,1,0x61,0x6e,0x6e,0x17,0x63,0x74,0x75,0x61,0x74,
-0x69,0x6f,0x6e,0xa3,0x8e,0x15,0x65,0x6d,0x65,0x6e,0x74,0x61,1,0x6c,0x50,0x72,
-0x1e,0x79,0x70,0x72,0x69,0x76,0x61,0x74,0x65,0x75,0x73,0x65,0x61,0x72,0x65,0x61,
-1,0x61,0xa3,0x6d,0x62,0xa3,0x6e,3,0x61,0x5c,0x6d,0x78,0x70,0xa2,0x41,0x73,
-0x13,0x79,0x6d,0x62,0x6f,0x1f,0x6c,0x73,0x61,0x6e,0x64,0x70,0x69,0x63,0x74,0x6f,
-0x67,0x72,0x61,0x70,0x68,0x73,0xa5,5,0x14,0x72,0x72,0x6f,0x77,0x73,2,0x61,
-0xa3,0x67,0x62,0xa3,0x68,0x63,0xa3,0xfa,0x13,0x61,0x74,0x68,0x65,0x1f,0x6d,0x61,
-0x74,0x69,0x63,0x61,0x6c,0x6f,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,0xa3,0x6a,
-0x19,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xa3,0x8e,0x61,0x5a,0x68,
-0x84,0x69,0xa2,0x5b,0x6d,0x16,0x61,0x6c,0x6c,0x66,0x6f,0x72,0x6d,1,0x73,0xa3,
-0x54,0x76,0x16,0x61,0x72,0x69,0x61,0x6e,0x74,0x73,0xa3,0x54,1,0x6d,0x36,0x75,
-0x16,0x72,0x61,0x73,0x68,0x74,0x72,0x61,0xa3,0xa1,0x15,0x61,0x72,0x69,0x74,0x61,
-0x6e,0xa3,0xac,1,0x61,0x52,0x6f,0x13,0x72,0x74,0x68,0x61,0x1f,0x6e,0x64,0x66,
-0x6f,0x72,0x6d,0x61,0x74,0x63,0x6f,0x6e,0x74,0x72,0x6f,0x6c,0x73,0xa3,0xf7,1,
-0x72,0x2e,0x76,0x12,0x69,0x61,0x6e,0xa3,0x79,0x12,0x61,0x64,0x61,0xa3,0xd9,1,
-0x64,0x50,0x6e,0x13,0x68,0x61,0x6c,0x61,0x50,0x1d,0x61,0x72,0x63,0x68,0x61,0x69,
-0x63,0x6e,0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0xf9,0x13,0x64,0x68,0x61,0x6d,0xa3,
-0xf8,5,0x72,0x35,0x72,0x44,0x73,0x64,0x75,1,0x61,0xa3,0x4e,0x6e,0x17,0x63,
-0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x71,0x17,0x69,0x76,0x61,0x74,0x65,0x75,0x73,
-0x65,0xa2,0x4e,0x13,0x61,0x72,0x65,0x61,0xa3,0x4e,0x1b,0x61,0x6c,0x74,0x65,0x72,
-0x70,0x61,0x68,0x6c,0x61,0x76,0x69,0xa3,0xf6,0x61,0x40,0x68,0x82,0x6c,0x19,0x61,
-0x79,0x69,0x6e,0x67,0x63,0x61,0x72,0x64,0x73,0xa3,0xcc,2,0x68,0x38,0x6c,0x4a,
-0x75,0x15,0x63,0x69,0x6e,0x68,0x61,0x75,0xa3,0xf5,0x17,0x61,0x77,0x68,0x68,0x6d,
-0x6f,0x6e,0x67,0xa3,0xf3,0x15,0x6d,0x79,0x72,0x65,0x6e,0x65,0xa3,0xf4,1,0x61,
-0x8e,0x6f,1,0x65,0x74,0x6e,0x16,0x65,0x74,0x69,0x63,0x65,0x78,0x74,0xa2,0x72,
-1,0x65,0x2c,0x73,0x11,0x75,0x70,0xa3,0x8d,0x15,0x6e,0x73,0x69,0x6f,0x6e,0x73,
-0xa2,0x72,0x19,0x73,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x8d,0x15,
-0x6e,0x69,0x63,0x69,0x61,0x6e,0xa3,0x97,1,0x67,0x3e,0x69,0x13,0x73,0x74,0x6f,
-0x73,0xa2,0xa6,0x13,0x64,0x69,0x73,0x63,0xa3,0xa6,0x12,0x73,0x70,0x61,0xa3,0x96,
-1,0x65,0x5c,0x75,1,0x6d,0x2a,0x6e,0x11,0x69,0x63,0x67,0x10,0x69,0xa2,0xc0,
-0x1d,0x6e,0x75,0x6d,0x65,0x72,0x61,0x6c,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,
-0xc0,0x13,0x6a,0x61,0x6e,0x67,0xa3,0xa3,0x6d,0xa2,0xc3,0x6e,0xa6,0xd2,0x6f,5,
-0x70,0x4b,0x70,0x46,0x72,0x7a,0x73,1,0x61,0x30,0x6d,0x13,0x61,0x6e,0x79,0x61,
-0xa3,0x7a,0x11,0x67,0x65,0xa5,0xf,0x18,0x74,0x69,0x63,0x61,0x6c,0x63,0x68,0x61,
-0x72,0x1f,0x61,0x63,0x74,0x65,0x72,0x72,0x65,0x63,0x6f,0x67,0x6e,0x69,0x74,0x69,
-0x6f,0x6e,0x85,1,0x69,0x46,0x6e,0x1e,0x61,0x6d,0x65,0x6e,0x74,0x61,0x6c,0x64,
-0x69,0x6e,0x67,0x62,0x61,0x74,0x73,0xa3,0xf2,0x11,0x79,0x61,0x47,0x63,0xa2,0x66,
-0x67,0xa2,0x66,0x6c,1,0x63,0xa2,0x57,0x64,5,0x70,0x2d,0x70,0x36,0x73,0x56,
-0x74,0x14,0x75,0x72,0x6b,0x69,0x63,0xa3,0xbf,0x11,0x65,0x72,1,0x6d,0x2e,0x73,
-0x12,0x69,0x61,0x6e,0xa3,0x8c,0x11,0x69,0x63,0xa3,0xf1,0x1a,0x6f,0x75,0x74,0x68,
-0x61,0x72,0x61,0x62,0x69,0x61,0x6e,0xa3,0xbb,0x68,0x42,0x69,0x54,0x6e,0x1a,0x6f,
-0x72,0x74,0x68,0x61,0x72,0x61,0x62,0x69,0x61,0x6e,0xa3,0xf0,0x17,0x75,0x6e,0x67,
-0x61,0x72,0x69,0x61,0x6e,0xa5,4,0x14,0x74,0x61,0x6c,0x69,0x63,0xa3,0x58,0x13,
-0x68,0x69,0x6b,0x69,0xa3,0x9d,0x10,0x72,0x85,0x12,0x68,0x61,0x6d,0x65,6,0x6f,
-0x86,0x6f,0x6c,0x72,0xa2,0x61,0x75,0xa2,0x62,0x79,0x14,0x61,0x6e,0x6d,0x61,0x72,
-0x58,0x12,0x65,0x78,0x74,2,0x61,0xa3,0xb6,0x62,0xa3,0xee,0x65,0x13,0x6e,0x64,
-0x65,0x64,1,0x61,0xa3,0xb6,0x62,0xa3,0xee,1,0x64,0x52,0x6e,0x15,0x67,0x6f,
-0x6c,0x69,0x61,0x6e,0x6a,0x12,0x73,0x75,0x70,0xa4,0xd,0x16,0x70,0x6c,0x65,0x6d,
-0x65,0x6e,0x74,0xa5,0xd,0x10,0x69,0xa2,0xec,0x13,0x66,0x69,0x65,0x72,1,0x6c,
-0x3c,0x74,0x19,0x6f,0x6e,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x73,0xa3,0x8a,0x15,
-0x65,0x74,0x74,0x65,0x72,0x73,0x2d,0x10,0x6f,0xa3,0xed,1,0x6c,0x44,0x73,0x11,
-0x69,0x63,0xa2,0x5c,0x18,0x61,0x6c,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5c,
-0x13,0x74,0x61,0x6e,0x69,0xa5,3,0x61,0xa2,0x9b,0x65,0xa4,0x36,0x69,1,0x61,
-0xa2,0x8f,0x73,0x10,0x63,5,0x70,0x18,0x70,0xa2,0x71,0x73,0x36,0x74,0x17,0x65,
-0x63,0x68,0x6e,0x69,0x63,0x61,0x6c,0x81,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x8f,
-0x61,0xa2,0x66,0x65,0x46,0x6d,0x19,0x61,0x74,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,
-0x73,1,0x61,0xa3,0x66,0x62,0xa3,0x69,0x17,0x6c,0x6c,0x61,0x6e,0x65,0x6f,0x75,
-0x73,2,0x6d,0x3a,0x73,0x6c,0x74,0x17,0x65,0x63,0x68,0x6e,0x69,0x63,0x61,0x6c,
-0x81,0x11,0x61,0x74,0x1f,0x68,0x65,0x6d,0x61,0x74,0x69,0x63,0x61,0x6c,0x73,0x79,
-0x6d,0x62,0x6f,0x6c,0x73,1,0x61,0xa3,0x66,0x62,0xa3,0x69,0x15,0x79,0x6d,0x62,
-0x6f,0x6c,0x73,0x8e,0x12,0x61,0x6e,0x64,1,0x61,0x3c,0x70,0x19,0x69,0x63,0x74,
-0x6f,0x67,0x72,0x61,0x70,0x68,0x73,0xa3,0xcd,0x14,0x72,0x72,0x6f,0x77,0x73,0xa3,
-0x73,0x10,0x6f,0xa3,0xd8,5,0x72,0x62,0x72,0xa2,0x4c,0x73,0xa2,0x50,0x74,0x10,
-0x68,2,0x61,0x3a,0x65,0x4a,0x6f,0x17,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,
-0x7f,0x16,0x6c,0x70,0x68,0x61,0x6e,0x75,0x6d,0xa3,0x5d,0x16,0x6d,0x61,0x74,0x69,
-0x63,0x61,0x6c,1,0x61,0x36,0x6f,0x17,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,
-0x7f,0x11,0x6c,0x70,0x1f,0x68,0x61,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x73,0x79,
-0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5d,0x13,0x63,0x68,0x65,0x6e,0xa5,0xc,0x18,0x61,
-0x72,0x61,0x6d,0x67,0x6f,0x6e,0x64,0x69,0xa5,0x14,0x68,0x4c,0x6c,0x7a,0x6e,1,
-0x64,0x34,0x69,0x15,0x63,0x68,0x61,0x65,0x61,0x6e,0xa3,0xea,0x12,0x61,0x69,0x63,
-0xa3,0xc6,1,0x61,0x3e,0x6a,0x12,0x6f,0x6e,0x67,0xa2,0xaa,0x14,0x74,0x69,0x6c,
-0x65,0x73,0xa3,0xaa,0x13,0x6a,0x61,0x6e,0x69,0xa3,0xe9,0x15,0x61,0x79,0x61,0x6c,
-0x61,0x6d,0x4f,2,0x65,0x66,0x6e,0x98,0x72,0x14,0x6f,0x69,0x74,0x69,0x63,1,
-0x63,0x3c,0x68,0x19,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,0x68,0x73,0xa3,0xd7,
-0x15,0x75,0x72,0x73,0x69,0x76,0x65,0xa3,0xd6,0x17,0x74,0x65,0x69,0x6d,0x61,0x79,
-0x65,0x6b,0xa2,0xb8,0x12,0x65,0x78,0x74,0xa2,0xd5,0x16,0x65,0x6e,0x73,0x69,0x6f,
-0x6e,0x73,0xa3,0xd5,0x18,0x64,0x65,0x6b,0x69,0x6b,0x61,0x6b,0x75,0x69,0xa3,0xeb,
-5,0x6b,0x23,0x6b,0x4c,0x6f,0x50,0x75,1,0x6d,0x2c,0x73,0x11,0x68,0x75,0xa5,
-0x15,0x17,0x62,0x65,0x72,0x66,0x6f,0x72,0x6d,0x73,0x7b,0x10,0x6f,0xa3,0x92,0x14,
-0x62,0x6c,0x6f,0x63,0x6b,0x21,0x61,0x44,0x62,0x21,0x65,0x10,0x77,1,0x61,0xa5,
-0xe,0x74,0x14,0x61,0x69,0x6c,0x75,0x65,0xa3,0x8b,0x16,0x62,0x61,0x74,0x61,0x65,
-0x61,0x6e,0xa3,0xef,0x67,0xc3,0xcd,0x6a,0xc1,0x95,0x6a,0xa2,0xc5,0x6b,0xa2,0xde,
-0x6c,4,0x61,0x54,0x65,0xa2,0x61,0x69,0xa2,0x78,0x6f,0xa2,0xa7,0x79,1,0x63,
-0x2e,0x64,0x12,0x69,0x61,0x6e,0xa3,0xa9,0x12,0x69,0x61,0x6e,0xa3,0xa7,1,0x6f,
-0x55,0x74,0x11,0x69,0x6e,1,0x31,0x82,0x65,0x11,0x78,0x74,4,0x61,0x5c,0x62,
-0x29,0x63,0xa3,0x94,0x64,0xa3,0x95,0x65,0xa2,0xe7,0x13,0x6e,0x64,0x65,0x64,4,
-0x61,0x36,0x62,0x29,0x63,0xa3,0x94,0x64,0xa3,0x95,0x65,0xa3,0xe7,0x26,0x18,0x64,
-0x64,0x69,0x74,0x69,0x6f,0x6e,0x61,0x6c,0x6d,0x24,0x12,0x73,0x75,0x70,0x24,0x16,
-0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0x25,1,0x70,0x42,0x74,0x1d,0x74,0x65,0x72,
-0x6c,0x69,0x6b,0x65,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x79,0x12,0x63,0x68,0x61,
-0xa3,0x9c,2,0x6d,0x2e,0x6e,0x34,0x73,0x10,0x75,0xa3,0xb0,0x11,0x62,0x75,0xa3,
-0x6f,0x12,0x65,0x61,0x72,1,0x61,0xa3,0xe8,0x62,1,0x69,0x38,0x73,0x17,0x79,
-0x6c,0x6c,0x61,0x62,0x61,0x72,0x79,0xa3,0x75,0x17,0x64,0x65,0x6f,0x67,0x72,0x61,
-0x6d,0x73,0xa3,0x76,0x1a,0x77,0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,
-0xa3,0x4d,0x10,0x61,1,0x6d,0x32,0x76,0x14,0x61,0x6e,0x65,0x73,0x65,0xa3,0xb5,
-0x10,0x6f,0x5c,0x12,0x65,0x78,0x74,1,0x61,0xa3,0xb4,0x62,0xa3,0xb9,1,0x61,
-0x80,0x68,3,0x61,0x3c,0x6d,0x4c,0x6f,0x64,0x75,0x15,0x64,0x61,0x77,0x61,0x64,
-0x69,0xa3,0xe6,0x16,0x72,0x6f,0x73,0x68,0x74,0x68,0x69,0xa3,0x89,0x11,0x65,0x72,
-0x68,0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x71,0x12,0x6a,0x6b,0x69,0xa3,
-0xe5,3,0x69,0x3a,0x6e,0x42,0x74,0xa2,0x51,0x79,0x13,0x61,0x68,0x6c,0x69,0xa3,
-0xa2,0x12,0x74,0x68,0x69,0xa3,0xc1,3,0x61,0x34,0x62,0x76,0x67,0x7c,0x6e,0x12,
-0x61,0x64,0x61,0x4d,1,0x65,0x40,0x73,0x11,0x75,0x70,0xa2,0xcb,0x16,0x70,0x6c,
-0x65,0x6d,0x65,0x6e,0x74,0xa3,0xcb,0x11,0x78,0x74,1,0x61,0xa5,0x13,0x65,0x14,
-0x6e,0x64,0x65,0x64,0x61,0xa5,0x13,0x11,0x75,0x6e,0xa3,0x42,0x11,0x78,0x69,0x96,
-0x17,0x72,0x61,0x64,0x69,0x63,0x61,0x6c,0x73,0x97,0x14,0x61,0x6b,0x61,0x6e,0x61,
-0x9e,1,0x65,0x4c,0x70,0x10,0x68,0x1f,0x6f,0x6e,0x65,0x74,0x69,0x63,0x65,0x78,
-0x74,0x65,0x6e,0x73,0x69,0x6f,0x6e,0x73,0xa3,0x6b,0x11,0x78,0x74,0xa3,0x6b,0x67,
-0xa2,0xa3,0x68,0xa4,0x53,0x69,3,0x64,0x4c,0x6d,0xa2,0x55,0x6e,0xa2,0x62,0x70,
-0x13,0x61,0x65,0x78,0x74,0x2a,0x16,0x65,0x6e,0x73,0x69,0x6f,0x6e,0x73,0x2b,1,
-0x63,0x99,0x65,0x17,0x6f,0x67,0x72,0x61,0x70,0x68,0x69,0x63,1,0x64,0x56,0x73,
-0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa4,0xb,0x1d,0x61,0x6e,0x64,0x70,0x75,0x6e,
-0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xa5,0xb,0x13,0x65,0x73,0x63,0x72,0x1f,
-0x69,0x70,0x74,0x69,0x6f,0x6e,0x63,0x68,0x61,0x72,0x61,0x63,0x74,0x65,0x72,0x73,
-0x99,0x1c,0x70,0x65,0x72,0x69,0x61,0x6c,0x61,0x72,0x61,0x6d,0x61,0x69,0x63,0xa3,
-0xba,1,0x64,0x62,0x73,0x1b,0x63,0x72,0x69,0x70,0x74,0x69,0x6f,0x6e,0x61,0x6c,
-0x70,0x61,1,0x68,0x32,0x72,0x14,0x74,0x68,0x69,0x61,0x6e,0xa3,0xbd,0x13,0x6c,
-0x61,0x76,0x69,0xa3,0xbe,0x1c,0x69,0x63,0x6e,0x75,0x6d,0x62,0x65,0x72,0x66,0x6f,
-0x72,0x6d,0x73,0xa3,0xb2,4,0x65,0x58,0x6c,0xa2,0x63,0x6f,0xa2,0x7b,0x72,0xa2,
-0x7f,0x75,1,0x6a,0x30,0x72,0x14,0x6d,0x75,0x6b,0x68,0x69,0x43,0x14,0x61,0x72,
-0x61,0x74,0x69,0x45,1,0x6e,0x8c,0x6f,1,0x6d,0x4e,0x72,0x13,0x67,0x69,0x61,
-0x6e,0x5a,0x12,0x73,0x75,0x70,0xa2,0x87,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,
-0xa3,0x87,0x1a,0x65,0x74,0x72,0x69,0x63,0x73,0x68,0x61,0x70,0x65,0x73,0x8c,0x12,
-0x65,0x78,0x74,0xa2,0xe3,0x14,0x65,0x6e,0x64,0x65,0x64,0xa3,0xe3,0x1e,0x65,0x72,
-0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x71,0x17,0x61,
-0x67,0x6f,0x6c,0x69,0x74,0x69,0x63,0xa2,0x88,0x12,0x73,0x75,0x70,0xa4,0xa,0x16,
-0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa5,0xa,0x13,0x74,0x68,0x69,0x63,0xa3,0x59,
-1,0x61,0x5c,0x65,0x11,0x65,0x6b,0x30,1,0x61,0x38,0x65,0x11,0x78,0x74,0x6e,
-0x14,0x65,0x6e,0x64,0x65,0x64,0x6f,0x17,0x6e,0x64,0x63,0x6f,0x70,0x74,0x69,0x63,
-0x31,0x13,0x6e,0x74,0x68,0x61,0xa3,0xe4,2,0x61,0xa2,0x48,0x65,0xa2,0xcf,0x69,
-1,0x67,0x30,0x72,0x14,0x61,0x67,0x61,0x6e,0x61,0x9d,0x10,0x68,1,0x70,0x3a,
-0x73,0x18,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,0xa3,0x4b,1,0x72,0x3c,
-0x75,0x19,0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,0xa3,0x4c,0x11,0x69,
-0x76,0x1f,0x61,0x74,0x65,0x75,0x73,0x65,0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,
-0x65,0x73,0xa3,0x4c,2,0x6c,0x32,0x6e,0x9a,0x74,0x12,0x72,0x61,0x6e,0xa5,2,
-0x10,0x66,2,0x61,0x58,0x6d,0x70,0x77,0x14,0x69,0x64,0x74,0x68,0x61,0x1f,0x6e,
-0x64,0x66,0x75,0x6c,0x6c,0x77,0x69,0x64,0x74,0x68,0x66,0x6f,0x72,0x6d,0x73,0xa3,
-0x57,0x1a,0x6e,0x64,0x66,0x75,0x6c,0x6c,0x66,0x6f,0x72,0x6d,0x73,0xa3,0x57,0x13,
-0x61,0x72,0x6b,0x73,0xa3,0x52,1,0x67,0x2e,0x75,0x12,0x6e,0x6f,0x6f,0xa3,0x63,
-0x11,0x75,0x6c,0xa2,0x4a,2,0x63,0x3c,0x6a,0x5e,0x73,0x17,0x79,0x6c,0x6c,0x61,
-0x62,0x6c,0x65,0x73,0xa3,0x4a,0x1f,0x6f,0x6d,0x70,0x61,0x74,0x69,0x62,0x69,0x6c,
-0x69,0x74,0x79,0x6a,0x61,0x6d,0x6f,0xa3,0x41,0x12,0x61,0x6d,0x6f,0x5c,0x17,0x65,
-0x78,0x74,0x65,0x6e,0x64,0x65,0x64,1,0x61,0xa3,0xb4,0x62,0xa3,0xb9,0x13,0x62,
-0x72,0x65,0x77,0x37,0x61,0xa2,0xe9,0x62,0xa6,0x29,0x63,0xa6,0xfe,0x64,0xac,0x7c,
-0x65,5,0x6d,0xa2,0x6d,0x86,0x6e,0x96,0x74,0x15,0x68,0x69,0x6f,0x70,0x69,0x63,
-0x5e,1,0x65,0x40,0x73,0x11,0x75,0x70,0xa2,0x86,0x16,0x70,0x6c,0x65,0x6d,0x65,
-0x6e,0x74,0xa3,0x86,0x11,0x78,0x74,0xa2,0x85,1,0x61,0xa3,0xc8,0x65,0x13,0x6e,
-0x64,0x65,0x64,0xa2,0x85,0x10,0x61,0xa3,0xc8,0x16,0x6f,0x74,0x69,0x63,0x6f,0x6e,
-0x73,0xa3,0xce,0x15,0x63,0x6c,0x6f,0x73,0x65,0x64,2,0x61,0x5a,0x63,0x9e,0x69,
-0x1c,0x64,0x65,0x6f,0x67,0x72,0x61,0x70,0x68,0x69,0x63,0x73,0x75,0x70,0xa2,0xc4,
-0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xc4,0x16,0x6c,0x70,0x68,0x61,0x6e,
-0x75,0x6d,0x86,1,0x65,0x2c,0x73,0x11,0x75,0x70,0xa3,0xc3,0x13,0x72,0x69,0x63,
-0x73,0x86,0x18,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xc3,0x11,0x6a,
-0x6b,0xa2,0x44,0x1f,0x6c,0x65,0x74,0x74,0x65,0x72,0x73,0x61,0x6e,0x64,0x6d,0x6f,
-0x6e,0x74,0x68,0x73,0xa3,0x44,0x61,0x36,0x67,0x62,0x6c,0x14,0x62,0x61,0x73,0x61,
-0x6e,0xa3,0xe2,0x13,0x72,0x6c,0x79,0x64,0x1f,0x79,0x6e,0x61,0x73,0x74,0x69,0x63,
-0x63,0x75,0x6e,0x65,0x69,0x66,0x6f,0x72,0x6d,0xa5,1,0x10,0x79,0x1f,0x70,0x74,
-0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,0x68,0x73,0xa3,0xc2,
-7,0x6e,0xc0,0xe5,0x6e,0x3e,0x72,0xa2,0x5d,0x73,0xa2,0xd8,0x76,0x14,0x65,0x73,
-0x74,0x61,0x6e,0xa3,0xbc,1,0x61,0x92,0x63,0x13,0x69,0x65,0x6e,0x74,1,0x67,
-0x34,0x73,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xa5,0x13,0x72,0x65,0x65,0x6b,
-1,0x6d,0x34,0x6e,0x15,0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0x7f,0x13,0x75,0x73,
-0x69,0x63,0xa2,0x7e,0x19,0x61,0x6c,0x6e,0x6f,0x74,0x61,0x74,0x69,0x6f,0x6e,0xa3,
-0x7e,0x10,0x74,0x1f,0x6f,0x6c,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,
-0x79,0x70,0x68,0x73,0xa3,0xfe,2,0x61,0x32,0x6d,0xa2,0x71,0x72,0x12,0x6f,0x77,
-0x73,0x7d,0x12,0x62,0x69,0x63,0x38,3,0x65,0x4a,0x6d,0x66,0x70,0xa2,0x43,0x73,
-0x11,0x75,0x70,0xa2,0x80,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x80,0x11,
-0x78,0x74,1,0x61,0xa3,0xd2,0x65,0x14,0x6e,0x64,0x65,0x64,0x61,0xa3,0xd2,0x12,
-0x61,0x74,0x68,0xa2,0xd3,0x18,0x65,0x6d,0x61,0x74,0x69,0x63,0x61,0x6c,0x61,0x1f,
-0x6c,0x70,0x68,0x61,0x62,0x65,0x74,0x69,0x63,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,
-0xa3,0xd3,1,0x66,0x42,0x72,0x1e,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,
-0x6e,0x66,0x6f,0x72,0x6d,0x73,1,0x61,0xa3,0x51,0x62,0xa3,0x55,0x14,0x65,0x6e,
-0x69,0x61,0x6e,0x35,0x12,0x63,0x69,0x69,0x23,0x64,0x9e,0x65,0xa2,0x42,0x68,0xa2,
-0x4d,0x6c,1,0x63,0x62,0x70,0x17,0x68,0x61,0x62,0x65,0x74,0x69,0x63,0x70,1,
-0x66,0xa3,0x50,0x72,0x1e,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,0x6e,0x66,
-0x6f,0x72,0x6d,0x73,0xa3,0x50,0x16,0x68,0x65,0x6d,0x69,0x63,0x61,0x6c,0xa2,0xd0,
-0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xd0,0x12,0x6c,0x61,0x6d,0xa5,7,
-0x1a,0x67,0x65,0x61,0x6e,0x6e,0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0x77,0x11,0x6f,
-0x6d,0xa3,0xfd,7,0x6f,0x71,0x6f,0x64,0x72,0xa2,0x41,0x75,0xa2,0x58,0x79,0x1b,
-0x7a,0x61,0x6e,0x74,0x69,0x6e,0x65,0x6d,0x75,0x73,0x69,0x63,0xa2,0x5b,0x18,0x61,
-0x6c,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5b,1,0x70,0x34,0x78,0x16,0x64,
-0x72,0x61,0x77,0x69,0x6e,0x67,0x89,0x14,0x6f,0x6d,0x6f,0x66,0x6f,0xa0,0x12,0x65,
-0x78,0x74,0xa2,0x43,0x14,0x65,0x6e,0x64,0x65,0x64,0xa3,0x43,0x10,0x61,1,0x68,
-0x40,0x69,0x12,0x6c,0x6c,0x65,0x92,0x17,0x70,0x61,0x74,0x74,0x65,0x72,0x6e,0x73,
-0x93,0x11,0x6d,0x69,0xa3,0xc9,1,0x67,0x2c,0x68,0x11,0x69,0x64,0xa3,0x64,0x14,
-0x69,0x6e,0x65,0x73,0x65,0xa3,0x81,0x61,0x48,0x65,0xa2,0x4e,0x68,0xa2,0x52,0x6c,
-0x1a,0x6f,0x63,0x6b,0x65,0x6c,0x65,0x6d,0x65,0x6e,0x74,0x73,0x8b,3,0x6c,0x34,
-0x6d,0x40,0x73,0x66,0x74,0x11,0x61,0x6b,0xa3,0xc7,0x14,0x69,0x6e,0x65,0x73,0x65,
-0xa3,0x93,0x11,0x75,0x6d,0xa2,0xb1,0x12,0x73,0x75,0x70,0xa2,0xca,0x16,0x70,0x6c,
-0x65,0x6d,0x65,0x6e,0x74,0xa3,0xca,1,0x69,0x30,0x73,0x13,0x61,0x76,0x61,0x68,
-0xa3,0xdd,0x15,0x63,0x6c,0x61,0x74,0x69,0x6e,0x23,0x14,0x6e,0x67,0x61,0x6c,0x69,
-0x41,0x16,0x61,0x69,0x6b,0x73,0x75,0x6b,0x69,0xa5,8,5,0x6f,0xc1,0x4c,0x6f,
-0xa2,0x55,0x75,0xa4,0x10,0x79,1,0x70,0x9c,0x72,0x14,0x69,0x6c,0x6c,0x69,0x63,
-0x32,1,0x65,0x4c,0x73,0x11,0x75,0x70,0xa2,0x61,0x16,0x70,0x6c,0x65,0x6d,0x65,
-0x6e,0x74,0xa2,0x61,0x12,0x61,0x72,0x79,0xa3,0x61,0x11,0x78,0x74,3,0x61,0xa3,
-0x9e,0x62,0xa3,0xa0,0x63,0xa5,9,0x65,0x13,0x6e,0x64,0x65,0x64,2,0x61,0xa3,
-0x9e,0x62,0xa3,0xa0,0x63,0xa5,9,0x1c,0x72,0x69,0x6f,0x74,0x73,0x79,0x6c,0x6c,
-0x61,0x62,0x61,0x72,0x79,0xa3,0x7b,3,0x6d,0x5a,0x6e,0xa2,0x95,0x70,0xa2,0xa0,
-0x75,0x17,0x6e,0x74,0x69,0x6e,0x67,0x72,0x6f,0x64,0xa2,0x9a,0x17,0x6e,0x75,0x6d,
-0x65,0x72,0x61,0x6c,0x73,0xa3,0x9a,2,0x62,0x3a,0x6d,0xa2,0x5f,0x70,0x15,0x61,
-0x74,0x6a,0x61,0x6d,0x6f,0xa3,0x41,0x14,0x69,0x6e,0x69,0x6e,0x67,2,0x64,0x46,
-0x68,0x9e,0x6d,0x1d,0x61,0x72,0x6b,0x73,0x66,0x6f,0x72,0x73,0x79,0x6d,0x62,0x6f,
-0x6c,0x73,0x77,0x1e,0x69,0x61,0x63,0x72,0x69,0x74,0x69,0x63,0x61,0x6c,0x6d,0x61,
-0x72,0x6b,0x73,0x2e,2,0x65,0x40,0x66,0xa6,0x1c,0x73,0x18,0x75,0x70,0x70,0x6c,
-0x65,0x6d,0x65,0x6e,0x74,0xa3,0x83,0x16,0x78,0x74,0x65,0x6e,0x64,0x65,0x64,0xa3,
-0xe0,0x17,0x61,0x6c,0x66,0x6d,0x61,0x72,0x6b,0x73,0xa3,0x52,0x11,0x6f,0x6e,0x1f,
-0x69,0x6e,0x64,0x69,0x63,0x6e,0x75,0x6d,0x62,0x65,0x72,0x66,0x6f,0x72,0x6d,0x73,
-0xa3,0xb2,0x1b,0x74,0x72,0x6f,0x6c,0x70,0x69,0x63,0x74,0x75,0x72,0x65,0x73,0x83,
-0x12,0x74,0x69,0x63,0xa2,0x84,0x1b,0x65,0x70,0x61,0x63,0x74,0x6e,0x75,0x6d,0x62,
-0x65,0x72,0x73,0xa3,0xdf,1,0x6e,0x3e,0x72,0x1b,0x72,0x65,0x6e,0x63,0x79,0x73,
-0x79,0x6d,0x62,0x6f,0x6c,0x73,0x75,0x15,0x65,0x69,0x66,0x6f,0x72,0x6d,0xa2,0x98,
-0x16,0x6e,0x75,0x6d,0x62,0x65,0x72,0x73,0xa2,0x99,0x1d,0x61,0x6e,0x64,0x70,0x75,
-0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xa3,0x99,0x61,0xa2,0xdb,0x68,0xa4,
-5,0x6a,0x10,0x6b,0xa2,0x47,4,0x63,0x86,0x65,0xa2,0x7d,0x72,0xa2,0x92,0x73,
-0xa2,0xa4,0x75,0x1f,0x6e,0x69,0x66,0x69,0x65,0x64,0x69,0x64,0x65,0x6f,0x67,0x72,
-0x61,0x70,0x68,0x73,0xa2,0x47,0x18,0x65,0x78,0x74,0x65,0x6e,0x73,0x69,0x6f,0x6e,
-5,0x64,0x65,0x64,0xa3,0xd1,0x65,0xa5,0,0x66,0xa5,0x12,0x14,0x6f,0x6d,0x70,
-0x61,0x74,0xa2,0x45,1,0x66,0x96,0x69,1,0x62,0x44,0x64,0x17,0x65,0x6f,0x67,
-0x72,0x61,0x70,0x68,0x73,0xa2,0x4f,0x12,0x73,0x75,0x70,0xa3,0x5f,0x14,0x69,0x6c,
-0x69,0x74,0x79,0xa2,0x45,1,0x66,0x54,0x69,0x18,0x64,0x65,0x6f,0x67,0x72,0x61,
-0x70,0x68,0x73,0xa2,0x4f,0x19,0x73,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,
-0xa3,0x5f,0x13,0x6f,0x72,0x6d,0x73,0xa3,0x53,0x11,0x78,0x74,5,0x64,9,0x64,
-0xa3,0xd1,0x65,0xa5,0,0x66,0xa5,0x12,0x61,0xa3,0x46,0x62,0xa3,0x5e,0x63,0xa3,
-0xc5,0x19,0x61,0x64,0x69,0x63,0x61,0x6c,0x73,0x73,0x75,0x70,0x94,0x16,0x70,0x6c,
-0x65,0x6d,0x65,0x6e,0x74,0x95,1,0x74,0x50,0x79,0x14,0x6d,0x62,0x6f,0x6c,0x73,
-0x9a,0x1d,0x61,0x6e,0x64,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,
-0x9b,0x14,0x72,0x6f,0x6b,0x65,0x73,0xa3,0x82,2,0x6e,0x48,0x72,0x64,0x75,0x1d,
-0x63,0x61,0x73,0x69,0x61,0x6e,0x61,0x6c,0x62,0x61,0x6e,0x69,0x61,0x6e,0xa3,0xde,
-0x1d,0x61,0x64,0x69,0x61,0x6e,0x73,0x79,0x6c,0x6c,0x61,0x62,0x69,0x63,0x73,0x63,
-0x12,0x69,0x61,0x6e,0xa3,0xa8,1,0x61,0x50,0x65,0x14,0x72,0x6f,0x6b,0x65,0x65,
-0x60,0x12,0x73,0x75,0x70,0xa2,0xff,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,
-0xff,1,0x6b,0x26,0x6d,0xa3,0xa4,0x11,0x6d,0x61,0xa3,0xd4,3,0x65,0x3e,0x69,
-0x7e,0x6f,0xa2,0x5d,0x75,0x15,0x70,0x6c,0x6f,0x79,0x61,0x6e,0xa3,0xe1,1,0x73,
-0x50,0x76,0x16,0x61,0x6e,0x61,0x67,0x61,0x72,0x69,0x3e,0x12,0x65,0x78,0x74,0xa2,
-0xb3,0x14,0x65,0x6e,0x64,0x65,0x64,0xa3,0xb3,0x13,0x65,0x72,0x65,0x74,0xa3,0x5a,
-1,0x61,0x30,0x6e,0x14,0x67,0x62,0x61,0x74,0x73,0x91,0x18,0x63,0x72,0x69,0x74,
-0x69,0x63,0x61,0x6c,0x73,0x2e,2,0x65,0x30,0x66,0x36,0x73,0x11,0x75,0x70,0xa3,
-0x83,0x11,0x78,0x74,0xa3,0xe0,0x18,0x6f,0x72,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,
-0x77,0x13,0x6d,0x69,0x6e,0x6f,0xa2,0xab,0x14,0x74,0x69,0x6c,0x65,0x73,0xa3,0xab,
-8,0x6d,0x5f,0x6d,0x3a,0x6e,0x48,0x73,0x7a,0x76,0xa2,0x4b,0x77,0x12,0x69,0x64,
-0x65,0x43,0x11,0x65,0x64,0x32,0x12,0x69,0x61,0x6c,0x33,2,0x61,0x40,0x62,0x37,
-0x6f,1,0x62,0x28,0x6e,0x10,0x65,0x21,0x13,0x72,0x65,0x61,0x6b,0x37,0x10,0x72,
-0x34,0x12,0x72,0x6f,0x77,0x35,2,0x6d,0x38,0x71,0x46,0x75,1,0x62,0x3d,0x70,
-0x3e,0x11,0x65,0x72,0x3f,1,0x61,0x24,0x6c,0x39,0x11,0x6c,0x6c,0x39,1,0x72,
-0x3b,0x75,0x12,0x61,0x72,0x65,0x3b,0x12,0x65,0x72,0x74,0x40,0x13,0x69,0x63,0x61,
-0x6c,0x41,0x63,0x58,0x65,0x92,0x66,0x96,0x69,1,0x6e,0x36,0x73,0x10,0x6f,0x30,
-0x14,0x6c,0x61,0x74,0x65,0x64,0x31,0x11,0x69,0x74,0x2e,0x12,0x69,0x61,0x6c,0x2f,
-2,0x61,0x36,0x69,0x48,0x6f,0x10,0x6d,0x24,0x12,0x70,0x61,0x74,0x25,0x10,0x6e,
-0x22,0x15,0x6f,0x6e,0x69,0x63,0x61,0x6c,0x23,0x13,0x72,0x63,0x6c,0x65,0x27,0x11,
-0x6e,0x63,0x27,2,0x69,0x3a,0x6f,0x44,0x72,0x10,0x61,0x2c,0x14,0x63,0x74,0x69,
-0x6f,0x6e,0x2d,0x10,0x6e,0x28,0x11,0x61,0x6c,0x29,0x11,0x6e,0x74,0x2b,4,0x61,
-0x3a,0x66,0x4c,0x68,0x5e,0x6e,0x70,0x77,0x2a,0x12,0x69,0x64,0x65,0x2b,0x22,0x17,
-0x6d,0x62,0x69,0x67,0x75,0x6f,0x75,0x73,0x23,0x26,0x17,0x75,0x6c,0x6c,0x77,0x69,
-0x64,0x74,0x68,0x27,0x24,0x17,0x61,0x6c,0x66,0x77,0x69,0x64,0x74,0x68,0x25,0x20,
-1,0x61,0x30,0x65,0x14,0x75,0x74,0x72,0x61,0x6c,0x21,0x28,0x13,0x72,0x72,0x6f,
-0x77,0x29,0xd,0x6e,0xc0,0xfb,0x73,0x6d,0x73,0x3a,0x74,0x98,0x75,0xa2,0x49,0x7a,
-2,0x6c,0x3b,0x70,0x3d,0x73,0x39,5,0x6f,0x28,0x6f,0x57,0x70,0x34,0x75,0x16,
-0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x45,0x11,0x61,0x63,1,0x65,0x32,0x69,0x15,
-0x6e,0x67,0x6d,0x61,0x72,0x6b,0x31,0x18,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,
-0x72,0x39,0x63,0x53,0x6b,0x55,0x6d,0x51,0x1d,0x69,0x74,0x6c,0x65,0x63,0x61,0x73,
-0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x27,1,0x6e,0x40,0x70,0x1c,0x70,0x65,0x72,
-0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x23,0x17,0x61,0x73,0x73,0x69,
-0x67,0x6e,0x65,0x64,0x21,0x6e,0x8a,0x6f,0xa2,0x47,0x70,8,0x66,0x14,0x66,0x5b,
-0x69,0x59,0x6f,0x4f,0x72,0x24,0x73,0x49,0x17,0x69,0x76,0x61,0x74,0x65,0x75,0x73,
-0x65,0x43,0x61,0x2c,0x63,0x4d,0x64,0x47,0x65,0x4b,0x1f,0x72,0x61,0x67,0x72,0x61,
-0x70,0x68,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x3d,2,0x64,0x33,0x6c,
-0x35,0x6f,0x36,0x1b,0x6e,0x73,0x70,0x61,0x63,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,
-0x2d,1,0x70,0x7c,0x74,0x12,0x68,0x65,0x72,3,0x6c,0x38,0x6e,0x42,0x70,0x4c,
-0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0x57,0x14,0x65,0x74,0x74,0x65,0x72,0x2b,0x14,
-0x75,0x6d,0x62,0x65,0x72,0x37,0x19,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,
-0x6e,0x4f,0x1c,0x65,0x6e,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,
-0x49,0x66,0x9e,0x66,0x88,0x69,0xa2,0x4b,0x6c,0xa2,0x5c,0x6d,4,0x61,0x60,0x63,
-0x31,0x65,0x2f,0x6e,0x2d,0x6f,0x15,0x64,0x69,0x66,0x69,0x65,0x72,1,0x6c,0x30,
-0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0x55,0x14,0x65,0x74,0x74,0x65,0x72,0x29,0x17,
-0x74,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x51,1,0x69,0x2e,0x6f,0x13,0x72,0x6d,
-0x61,0x74,0x41,0x1d,0x6e,0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,
-0x6f,0x6e,0x5b,0x10,0x6e,0x1f,0x69,0x74,0x69,0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,
-0x75,0x61,0x74,0x69,0x6f,0x6e,0x59,6,0x6d,0x18,0x6d,0x29,0x6f,0x28,0x74,0x27,
-0x75,0x23,0x2a,0x1c,0x77,0x65,0x72,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,
-0x72,0x25,0x65,0x28,0x69,0x3c,0x6c,0x25,0x19,0x74,0x74,0x65,0x72,0x6e,0x75,0x6d,
-0x62,0x65,0x72,0x35,0x1a,0x6e,0x65,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,
-0x3b,0x63,0x44,0x64,0xa2,0x60,0x65,0x1b,0x6e,0x63,0x6c,0x6f,0x73,0x69,0x6e,0x67,
-0x6d,0x61,0x72,0x6b,0x2f,6,0x6e,0x39,0x6e,0x46,0x6f,0x4e,0x73,0x45,0x75,0x1b,
-0x72,0x72,0x65,0x6e,0x63,0x79,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x53,0x20,0x12,0x74,
-0x72,0x6c,0x3f,0x42,0x10,0x6e,1,0x6e,0x2c,0x74,0x12,0x72,0x6f,0x6c,0x3f,0x1f,
-0x65,0x63,0x74,0x6f,0x72,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,
-0x4d,0x63,0x3f,0x66,0x41,0x6c,0x1d,0x6f,0x73,0x65,0x70,0x75,0x6e,0x63,0x74,0x75,
-0x61,0x74,0x69,0x6f,0x6e,0x4b,2,0x61,0x30,0x65,0x4a,0x69,0x12,0x67,0x69,0x74,
-0x33,0x1c,0x73,0x68,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x47,
-0x1a,0x63,0x69,0x6d,0x61,0x6c,0x6e,0x75,0x6d,0x62,0x65,0x72,0x33,0,0x12,0x6d,
-0xc2,0x3f,0x73,0xa1,0x73,0x4e,0x74,0xa2,0x56,0x77,0xa2,0x72,0x79,0xa2,0x73,0x7a,
-1,0x61,0x2c,0x68,0x12,0x61,0x69,0x6e,0x8b,0x11,0x69,0x6e,0x85,5,0x74,0x22,
-0x74,0x38,0x77,0x4c,0x79,0x16,0x72,0x69,0x61,0x63,0x77,0x61,0x77,0x6f,0x18,0x72,
-0x61,0x69,0x67,0x68,0x74,0x77,0x61,0x77,0xa3,0x55,0x15,0x61,0x73,0x68,0x6b,0x61,
-0x66,0x6d,0x61,0x2e,0x65,0x38,0x68,0x11,0x69,0x6e,0x6b,0x10,0x64,0x62,0x11,0x68,
-0x65,0x65,1,0x65,0x2e,0x6d,0x13,0x6b,0x61,0x74,0x68,0x69,0x10,0x6e,0x67,1,
-0x61,0x4e,0x65,1,0x68,0x28,0x74,0x10,0x68,0x77,0x16,0x6d,0x61,0x72,0x62,0x75,
-0x74,0x61,0x74,0x13,0x67,0x6f,0x61,0x6c,0x3d,1,0x68,0x71,0x77,0x73,0x11,0x61,
-0x77,0x79,1,0x65,0x32,0x75,0x11,0x64,0x68,0x80,0x11,0x68,0x65,0x83,0x10,0x68,
-0x7a,1,0x62,0x34,0x77,0x16,0x69,0x74,0x68,0x74,0x61,0x69,0x6c,0x7f,0x14,0x61,
-0x72,0x72,0x65,0x65,0x7d,0x6d,0x6c,0x6e,0xa4,0x6b,0x70,0xa4,0x88,0x71,0xa4,0x88,
-0x72,1,0x65,0x38,0x6f,0x18,0x68,0x69,0x6e,0x67,0x79,0x61,0x79,0x65,0x68,0x93,
-1,0x68,0x5f,0x76,0x16,0x65,0x72,0x73,0x65,0x64,0x70,0x65,0x61,2,0x61,0x2e,
-0x65,0xa4,0x3e,0x69,0x10,0x6d,0x53,1,0x6c,0xa2,0xe7,0x6e,0x16,0x69,0x63,0x68,
-0x61,0x65,0x61,0x6e,0,0x12,0x6e,0x76,0x73,0x51,0x73,0x3e,0x74,0x5c,0x77,0xa0,
-0x79,0xa2,0x42,0x7a,0x13,0x61,0x79,0x69,0x6e,0xa3,0x54,0x10,0x61,1,0x64,0x2e,
-0x6d,0x12,0x65,0x6b,0x68,0xa3,0x4c,0x11,0x68,0x65,0xa3,0x4b,3,0x61,0x38,0x65,
-0x3c,0x68,0x4a,0x77,0x13,0x65,0x6e,0x74,0x79,0xa3,0x51,0x10,0x77,0xa3,0x4d,1,
-0x6e,0xa3,0x4e,0x74,0x10,0x68,0xa3,0x4f,0x14,0x61,0x6d,0x65,0x64,0x68,0xa3,0x50,
-0x11,0x61,0x77,0xa3,0x52,0x12,0x6f,0x64,0x68,0xa3,0x53,0x6e,0x3a,0x6f,0x40,0x70,
-0x46,0x71,0x4a,0x72,0x12,0x65,0x73,0x68,0xa3,0x4a,0x11,0x75,0x6e,0xa3,0x46,0x11,
-0x6e,0x65,0xa3,0x47,0x10,0x65,0xa3,0x48,0x12,0x6f,0x70,0x68,0xa3,0x49,0x67,0x33,
-0x67,0x38,0x68,0x40,0x6b,0x5e,0x6c,0x66,0x6d,0x11,0x65,0x6d,0xa3,0x45,0x13,0x69,
-0x6d,0x65,0x6c,0xa1,1,0x65,0x32,0x75,0x14,0x6e,0x64,0x72,0x65,0x64,0xa3,0x42,
-0x11,0x74,0x68,0xa3,0x41,0x12,0x61,0x70,0x68,0xa3,0x43,0x14,0x61,0x6d,0x65,0x64,
-0x68,0xa3,0x44,0x61,0x34,0x62,0x4a,0x64,0x50,0x66,0x12,0x69,0x76,0x65,0x9f,1,
-0x6c,0x2a,0x79,0x11,0x69,0x6e,0x97,0x12,0x65,0x70,0x68,0x95,0x12,0x65,0x74,0x68,
-0x99,1,0x61,0x30,0x68,0x14,0x61,0x6d,0x65,0x64,0x68,0x9d,0x13,0x6c,0x65,0x74,
-0x68,0x9b,0x15,0x61,0x79,0x61,0x6c,0x61,0x6d,6,0x6e,0x2c,0x6e,0x34,0x72,0x5e,
-0x73,0x62,0x74,0x11,0x74,0x61,0xa3,0x63,2,0x67,0x2e,0x6e,0x32,0x79,0x10,0x61,
-0xa3,0x60,0x10,0x61,0xa3,0x5d,1,0x61,0xa3,0x5e,0x6e,0x10,0x61,0xa3,0x5f,0x10,
-0x61,0xa3,0x61,0x11,0x73,0x61,0xa3,0x62,0x62,0x3c,0x6a,0x42,0x6c,0x10,0x6c,1,
-0x61,0xa3,0x5b,0x6c,0x10,0x61,0xa3,0x5c,0x11,0x68,0x61,0xa3,0x59,0x10,0x61,0xa3,
-0x5a,0x11,0x65,0x6d,0x51,2,0x6f,0x2c,0x75,0x50,0x79,0x10,0x61,0x91,1,0x6a,
-0x28,0x6f,0x10,0x6e,0x55,0x1a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x67,0x72,0x6f,0x75,
-0x70,0x21,0x10,0x6e,0x57,0x10,0x65,0x59,0x10,0x61,1,0x66,0x5b,0x70,0x10,0x68,
-0x5d,0x66,0x7b,0x66,0x42,0x67,0x7a,0x68,0x8a,0x6b,0xa2,0x56,0x6c,0x11,0x61,0x6d,
-0x4c,0x12,0x61,0x64,0x68,0x4f,2,0x61,0x3e,0x65,0x4a,0x69,0x19,0x6e,0x61,0x6c,
-0x73,0x65,0x6d,0x6b,0x61,0x74,0x68,0x35,0x15,0x72,0x73,0x69,0x79,0x65,0x68,0x8f,
-0x86,0x10,0x68,0x33,0x10,0x61,1,0x66,0x37,0x6d,0x11,0x61,0x6c,0x39,1,0x61,
-0x40,0x65,0x3e,1,0x68,0x28,0x74,0x10,0x68,0x45,0x40,0x13,0x67,0x6f,0x61,0x6c,
-0x43,1,0x68,0x3b,0x6d,0x1a,0x7a,0x61,0x6f,0x6e,0x68,0x65,0x68,0x67,0x6f,0x61,
-0x6c,0x3d,2,0x61,0x3a,0x68,0x44,0x6e,0x17,0x6f,0x74,0x74,0x65,0x64,0x68,0x65,
-0x68,0x4b,1,0x66,0x47,0x70,0x10,0x68,0x49,0x12,0x61,0x70,0x68,0x89,0x61,0x2e,
-0x62,0x8a,0x64,0xa2,0x51,0x65,0x31,2,0x66,0x3c,0x69,0x70,0x6c,1,0x61,0x28,
-0x65,0x10,0x66,0x27,0x11,0x70,0x68,0x25,0x14,0x72,0x69,0x63,0x61,0x6e,2,0x66,
-0x30,0x6e,0x36,0x71,0x11,0x61,0x66,0xa3,0x58,0x11,0x65,0x68,0xa3,0x56,0x12,0x6f,
-0x6f,0x6e,0xa3,0x57,0x10,0x6e,0x23,1,0x65,0x4a,0x75,0x10,0x72,0x1f,0x75,0x73,
-0x68,0x61,0x73,0x6b,0x69,0x79,0x65,0x68,0x62,0x61,0x72,0x72,0x65,0x65,0x8d,1,
-0x68,0x29,0x74,0x10,0x68,0x2b,0x11,0x61,0x6c,0x2c,0x16,0x61,0x74,0x68,0x72,0x69,
-0x73,0x68,0x2f,7,0x6e,0x2e,0x6e,0x2c,0x72,0x3e,0x74,0x56,0x75,0x21,0x18,0x6f,
-0x6e,0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x21,0x28,0x1a,0x69,0x67,0x68,0x74,0x6a,
-0x6f,0x69,0x6e,0x69,0x6e,0x67,0x29,0x2a,0x19,0x72,0x61,0x6e,0x73,0x70,0x61,0x72,
-0x65,0x6e,0x74,0x2b,0x63,0x23,0x64,0x40,0x6a,0x56,0x6c,0x26,0x19,0x65,0x66,0x74,
-0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x27,0x24,0x19,0x75,0x61,0x6c,0x6a,0x6f,0x69,
-0x6e,0x69,0x6e,0x67,0x25,0x19,0x6f,0x69,0x6e,0x63,0x61,0x75,0x73,0x69,0x6e,0x67,
-0x23,0,0x13,0x6e,0xc0,0xd0,0x73,0x49,0x73,0x48,0x75,0x78,0x77,0x84,0x78,0x9c,
-0x7a,0x10,0x77,0x58,1,0x6a,0x75,0x73,0x13,0x70,0x61,0x63,0x65,0x59,4,0x61,
-0x51,0x67,0x53,0x70,0x28,0x75,0x30,0x79,0x57,0x54,0x12,0x61,0x63,0x65,0x55,0x16,
-0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x53,0x15,0x6e,0x6b,0x6e,0x6f,0x77,0x6e,0x21,
-1,0x6a,0x5d,0x6f,0x17,0x72,0x64,0x6a,0x6f,0x69,0x6e,0x65,0x72,0x5d,0x10,0x78,
-0x21,0x6e,0x60,0x6f,0xa2,0x41,0x70,0xa2,0x50,0x71,0xa2,0x6e,0x72,1,0x65,0x24,
-0x69,0x6f,0x1e,0x67,0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,0x63,0x61,0x74,
-0x6f,0x72,0x6f,4,0x65,0x3e,0x6c,0x5b,0x6f,0x46,0x73,0x45,0x75,0x46,0x14,0x6d,
-0x65,0x72,0x69,0x63,0x47,0x15,0x78,0x74,0x6c,0x69,0x6e,0x65,0x5b,0x17,0x6e,0x73,
-0x74,0x61,0x72,0x74,0x65,0x72,0x45,0x10,0x70,0x48,0x1c,0x65,0x6e,0x70,0x75,0x6e,
-0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x49,1,0x6f,0x3e,0x72,0x4c,0x1a,0x65,
-0x66,0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x4d,0x4a,0x1b,0x73,0x74,0x66,
-0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x4b,0x10,0x75,0x4e,0x16,0x6f,0x74,
-0x61,0x74,0x69,0x6f,0x6e,0x4f,0x68,0x7b,0x68,0x50,0x69,0x86,0x6a,0xa2,0x61,0x6c,
-0xa2,0x65,0x6d,0x1c,0x61,0x6e,0x64,0x61,0x74,0x6f,0x72,0x79,0x62,0x72,0x65,0x61,
-0x6b,0x2d,4,0x32,0x5f,0x33,0x61,0x65,0x34,0x6c,0x6d,0x79,0x3a,0x13,0x70,0x68,
-0x65,0x6e,0x3b,0x19,0x62,0x72,0x65,0x77,0x6c,0x65,0x74,0x74,0x65,0x72,0x6d,2,
-0x64,0x28,0x6e,0x3c,0x73,0x41,0x3c,0x18,0x65,0x6f,0x67,0x72,0x61,0x70,0x68,0x69,
-0x63,0x3d,0x3e,1,0x66,0x3e,0x73,0x11,0x65,0x70,1,0x61,0x22,0x65,0x14,0x72,
-0x61,0x62,0x6c,0x65,0x3f,0x18,0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x41,
-2,0x6c,0x63,0x74,0x65,0x76,0x67,1,0x66,0x43,0x69,0x15,0x6e,0x65,0x66,0x65,
-0x65,0x64,0x43,0x61,0x40,0x62,0x70,0x63,0xa2,0x55,0x65,0xa2,0xdb,0x67,0x10,0x6c,
-0x38,0x11,0x75,0x65,0x39,2,0x69,0x23,0x6c,0x34,0x6d,0x16,0x62,0x69,0x67,0x75,
-0x6f,0x75,0x73,0x23,0x24,0x17,0x70,0x68,0x61,0x62,0x65,0x74,0x69,0x63,0x25,4,
-0x32,0x27,0x61,0x29,0x62,0x2b,0x6b,0x2d,0x72,0x12,0x65,0x61,0x6b,2,0x61,0x36,
-0x62,0x3e,0x73,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x57,0x13,0x66,0x74,0x65,0x72,
-0x29,1,0x65,0x2a,0x6f,0x11,0x74,0x68,0x27,0x13,0x66,0x6f,0x72,0x65,0x2b,7,
-0x6d,0x51,0x6d,0x33,0x6f,0x28,0x70,0x69,0x72,0x35,1,0x6d,0x76,0x6e,1,0x64,
-0x3c,0x74,0x1a,0x69,0x6e,0x67,0x65,0x6e,0x74,0x62,0x72,0x65,0x61,0x6b,0x2f,0x15,
-0x69,0x74,0x69,0x6f,0x6e,0x61,0x1f,0x6c,0x6a,0x61,0x70,0x61,0x6e,0x65,0x73,0x65,
-0x73,0x74,0x61,0x72,0x74,0x65,0x72,0x6b,1,0x62,0x3a,0x70,0x19,0x6c,0x65,0x78,
-0x63,0x6f,0x6e,0x74,0x65,0x78,0x74,0x51,0x18,0x69,0x6e,0x69,0x6e,0x67,0x6d,0x61,
-0x72,0x6b,0x33,0x61,0x6a,0x62,0x2f,0x6a,0x6b,0x6c,0x30,0x13,0x6f,0x73,0x65,0x70,
-1,0x61,0x38,0x75,0x18,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x31,0x18,
-0x72,0x65,0x6e,0x74,0x68,0x65,0x73,0x69,0x73,0x69,0x1b,0x72,0x72,0x69,0x61,0x67,
-0x65,0x72,0x65,0x74,0x75,0x72,0x6e,0x35,2,0x62,0x3e,0x6d,0x46,0x78,0x36,0x18,
-0x63,0x6c,0x61,0x6d,0x61,0x74,0x69,0x6f,0x6e,0x37,0x70,0x12,0x61,0x73,0x65,0x71,
-0x72,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,0x72,0x73,1,0x64,0x42,0x6e,1,0x6f,
-0x32,0x75,0x26,0x14,0x6d,0x65,0x72,0x69,0x63,0x27,0x11,0x6e,0x65,0x21,1,0x65,
-0x2e,0x69,0x24,0x12,0x67,0x69,0x74,0x25,0x22,0x14,0x63,0x69,0x6d,0x61,0x6c,0x23,
-0,0x18,0x6e,0xc3,0xc4,0x74,0xc1,0x51,0x77,0x7a,0x77,0xa2,0x4c,0x78,0xa2,0x60,
-0x79,0xa2,0x6a,0x7a,6,0x73,0x1e,0x73,0x34,0x78,0x42,0x79,0x48,0x7a,0x11,0x7a,
-0x7a,0xa3,0x67,0x10,0x79,1,0x65,0xa3,0xae,0x6d,0xa3,0x81,0x11,0x78,0x78,0xa3,
-0x66,0x11,0x79,0x79,0x21,0x61,0x30,0x69,0x58,0x6d,0x11,0x74,0x68,0xa3,0x80,0x10,
-0x6e,1,0x61,0x26,0x62,0xa3,0xb1,0x1a,0x62,0x61,0x7a,0x61,0x72,0x73,0x71,0x75,
-0x61,0x72,0x65,0xa3,0xb1,0x11,0x6e,0x68,0x23,1,0x61,0x2c,0x6f,0x11,0x6c,0x65,
-0xa3,0x9b,0x11,0x72,0x61,0xa2,0x92,0x15,0x6e,0x67,0x63,0x69,0x74,0x69,0xa3,0x92,
-1,0x70,0x2c,0x73,0x11,0x75,0x78,0xa3,0x65,0x11,0x65,0x6f,0x9b,0x10,0x69,0x72,
-0x11,0x69,0x69,0x73,0x74,0x4a,0x75,0xa2,0xba,0x76,1,0x61,0x2c,0x69,0x11,0x73,
-0x70,0xa3,0x64,0x10,0x69,0xa2,0x63,0x10,0x69,0xa3,0x63,5,0x67,0x36,0x67,0x68,
-0x68,0x6c,0x69,2,0x62,0x3a,0x66,0x4a,0x72,0x10,0x68,0xa2,0x9e,0x12,0x75,0x74,
-0x61,0xa3,0x9e,1,0x65,0x24,0x74,0x6f,0x12,0x74,0x61,0x6e,0x6f,0x14,0x69,0x6e,
-0x61,0x67,0x68,0x99,0x11,0x6c,0x67,0x75,0x10,0x61,1,0x61,0x24,0x69,0x6d,0x6a,
-0x11,0x6e,0x61,0x6b,0x61,0x30,0x65,0xa2,0x5b,0x66,0x11,0x6e,0x67,0x99,6,0x6c,
-0x21,0x6c,0x32,0x6d,0x38,0x6e,0x44,0x76,0x10,0x74,0xa3,0x7f,1,0x65,0x89,0x75,
-0x97,1,0x69,0x24,0x6c,0x67,0x10,0x6c,0x67,0x10,0x67,0xa2,0x9a,0x11,0x75,0x74,
-0xa3,0x9a,0x67,0x36,0x69,0x52,0x6b,0x10,0x72,0xa2,0x99,0x10,0x69,0xa3,0x99,1,
-0x61,0x30,0x62,0x7a,0x13,0x61,0x6e,0x77,0x61,0x7b,0x12,0x6c,0x6f,0x67,0x75,2,
-0x6c,0x32,0x74,0x34,0x76,0x12,0x69,0x65,0x74,0xa3,0x7f,0x10,0x65,0x89,0x12,0x68,
-0x61,0x6d,0xa3,0x6a,1,0x6c,0x2a,0x6e,0x10,0x67,0xa3,0x62,0x10,0x75,0x68,0x11,
-0x67,0x75,0x69,1,0x67,0x32,0x6e,0x14,0x6b,0x6e,0x6f,0x77,0x6e,0xa3,0x67,0x11,
-0x61,0x72,0x8a,0x13,0x69,0x74,0x69,0x63,0x8b,0x71,0xc0,0xfc,0x71,0xa2,0xce,0x72,
-0xa2,0xd3,0x73,6,0x69,0x7a,0x69,0x72,0x6f,0xa2,0x4c,0x75,0xa2,0x65,0x79,1,
-0x6c,0x46,0x72,4,0x63,0x65,0x65,0xa3,0x5f,0x69,0x2c,0x6a,0xa3,0x60,0x6e,0xa3,
-0x61,0x11,0x61,0x63,0x65,0x10,0x6f,0x94,0x16,0x74,0x69,0x6e,0x61,0x67,0x72,0x69,
-0x95,2,0x64,0x3c,0x67,0x4c,0x6e,1,0x64,0xa3,0x91,0x68,0x62,0x12,0x61,0x6c,
-0x61,0x63,0x10,0x64,0xa2,0xa6,0x12,0x68,0x61,0x6d,0xa3,0xa6,0x17,0x6e,0x77,0x72,
-0x69,0x74,0x69,0x6e,0x67,0xa3,0x70,1,0x72,0x36,0x79,0x10,0x6f,0xa2,0xb0,0x12,
-0x6d,0x62,0x6f,0xa3,0xb0,0x10,0x61,0xa2,0x98,0x16,0x73,0x6f,0x6d,0x70,0x65,0x6e,
-0x67,0xa3,0x98,0x11,0x6e,0x64,0xa2,0x71,0x14,0x61,0x6e,0x65,0x73,0x65,0xa3,0x71,
-0x61,0x5c,0x67,0xa2,0x43,0x68,1,0x61,0x2a,0x72,0x10,0x64,0xa3,0x97,2,0x72,
-0x28,0x76,0x30,0x77,0x87,0x12,0x61,0x64,0x61,0xa3,0x97,0x12,0x69,0x61,0x6e,0x87,
-2,0x6d,0x40,0x72,0x58,0x75,0x10,0x72,0xa2,0x6f,0x15,0x61,0x73,0x68,0x74,0x72,
-0x61,0xa3,0x6f,1,0x61,0x26,0x72,0xa3,0x7e,0x14,0x72,0x69,0x74,0x61,0x6e,0xa3,
-0x7e,1,0x61,0xa3,0x5e,0x62,0xa3,0x85,0x11,0x6e,0x77,0xa3,0x70,0x11,0x61,0x61,
-1,0x63,0x2f,0x69,0x23,3,0x65,0x3e,0x6a,0x48,0x6f,0x4e,0x75,0x10,0x6e,1,
-0x69,0x24,0x72,0x61,0x10,0x63,0x61,0x13,0x6a,0x61,0x6e,0x67,0xa3,0x6e,0x11,0x6e,
-0x67,0xa3,0x6e,0x11,0x72,0x6f,0xa3,0x5d,0x6e,0xa2,0x83,0x6f,0xa2,0xca,0x70,5,
-0x6c,0x1e,0x6c,0x44,0x72,0x4a,0x73,0x1b,0x61,0x6c,0x74,0x65,0x72,0x70,0x61,0x68,
-0x6c,0x61,0x76,0x69,0xa3,0x7b,0x11,0x72,0x64,0xa3,0x5c,0x11,0x74,0x69,0xa3,0x7d,
-0x61,0x7c,0x65,0xa2,0x54,0x68,3,0x61,0x3e,0x6c,0x4e,0x6e,0x5e,0x6f,0x16,0x65,
-0x6e,0x69,0x63,0x69,0x61,0x6e,0xa3,0x5b,0x10,0x67,0xa2,0x5a,0x12,0x73,0x70,0x61,
-0xa3,0x5a,2,0x69,0xa3,0x7a,0x70,0xa3,0x7b,0x76,0xa3,0x7c,0x10,0x78,0xa3,0x5b,
-2,0x68,0x3e,0x6c,0x50,0x75,0x10,0x63,0xa2,0xa5,0x14,0x69,0x6e,0x68,0x61,0x75,
-0xa3,0xa5,0x17,0x61,0x77,0x68,0x68,0x6d,0x6f,0x6e,0x67,0xa3,0x4b,0x10,0x6d,0xa2,
-0x90,0x14,0x79,0x72,0x65,0x6e,0x65,0xa3,0x90,0x11,0x72,0x6d,0xa3,0x59,5,0x6b,
-0x1e,0x6b,0x32,0x73,0x4a,0x75,0x12,0x73,0x68,0x75,0xa3,0x96,1,0x67,0x2e,0x6f,
-0xa2,0x57,0x10,0x6f,0xa3,0x57,0x10,0x62,0xa3,0x84,0x11,0x68,0x75,0xa3,0x96,0x61,
-0x42,0x62,0x60,0x65,0x10,0x77,1,0x61,0xa3,0xaa,0x74,0x14,0x61,0x69,0x6c,0x75,
-0x65,0x97,1,0x62,0x2a,0x72,0x10,0x62,0xa3,0x8e,0x15,0x61,0x74,0x61,0x65,0x61,
-0x6e,0xa3,0x8f,0x11,0x61,0x74,0xa3,0x8f,3,0x67,0x5a,0x6c,0x6c,0x72,0xa2,0x88,
-0x73,2,0x61,0x36,0x67,0x3c,0x6d,0x10,0x61,0x84,0x12,0x6e,0x79,0x61,0x85,0x11,
-0x67,0x65,0xa3,0xab,0x10,0x65,0xa3,0xab,1,0x61,0x2a,0x68,0x11,0x61,0x6d,0x5b,
-0x10,0x6d,0x5b,1,0x63,0xa2,0x55,0x64,5,0x70,0x2c,0x70,0x36,0x73,0x54,0x74,
-0x14,0x75,0x72,0x6b,0x69,0x63,0xa3,0x58,0x11,0x65,0x72,1,0x6d,0x2c,0x73,0x12,
-0x69,0x61,0x6e,0x9b,0x11,0x69,0x63,0xa3,0x59,0x1a,0x6f,0x75,0x74,0x68,0x61,0x72,
-0x61,0x62,0x69,0x61,0x6e,0xa3,0x85,0x68,0x42,0x69,0x54,0x6e,0x1a,0x6f,0x72,0x74,
-0x68,0x61,0x72,0x61,0x62,0x69,0x61,0x6e,0xa3,0x8e,0x17,0x75,0x6e,0x67,0x61,0x72,
-0x69,0x61,0x6e,0xa3,0x4c,0x14,0x74,0x61,0x6c,0x69,0x63,0x5d,1,0x68,0x26,0x6b,
-0xa3,0x6d,0x12,0x69,0x6b,0x69,0xa3,0x6d,2,0x69,0x2c,0x6b,0x30,0x79,0x10,0x61,
-0x5f,0x11,0x79,0x61,0x5f,0x10,0x68,0xa3,0x58,0x68,0xc2,0xc2,0x6b,0xc1,0xeb,0x6b,
-0xa2,0xf8,0x6c,0xa4,0x79,0x6d,8,0x6f,0x46,0x6f,0x48,0x72,0x74,0x74,0x80,0x75,
-0x86,0x79,1,0x61,0x28,0x6d,0x10,0x72,0x59,0x13,0x6e,0x6d,0x61,0x72,0x59,2,
-0x64,0x2e,0x6e,0x32,0x6f,0x10,0x6e,0xa3,0x72,0x10,0x69,0xa3,0xa3,0x10,0x67,0x56,
-0x14,0x6f,0x6c,0x69,0x61,0x6e,0x57,0x10,0x6f,0xa2,0x95,0x10,0x6f,0xa3,0x95,0x11,
-0x65,0x69,0xa3,0x73,0x11,0x6c,0x74,0xa2,0xa4,0x12,0x61,0x6e,0x69,0xa3,0xa4,0x61,
-0x36,0x65,0xa2,0x5b,0x69,0xa2,0x9e,0x6c,0x11,0x79,0x6d,0x55,5,0x72,0x1f,0x72,
-0x2e,0x73,0x3e,0x79,0x10,0x61,0xa3,0x55,0x10,0x63,0xa2,0xa9,0x12,0x68,0x65,0x6e,
-0xa3,0xa9,0x18,0x61,0x72,0x61,0x6d,0x67,0x6f,0x6e,0x64,0x69,0xa3,0xaf,0x68,0x54,
-0x6c,0x6a,0x6e,1,0x64,0x38,0x69,0xa2,0x79,0x15,0x63,0x68,0x61,0x65,0x61,0x6e,
-0xa3,0x79,0xa2,0x54,0x12,0x61,0x69,0x63,0xa3,0x54,1,0x61,0x26,0x6a,0xa3,0xa0,
-0x13,0x6a,0x61,0x6e,0x69,0xa3,0xa0,0x15,0x61,0x79,0x61,0x6c,0x61,0x6d,0x55,2,
-0x65,0x72,0x6e,0x84,0x72,1,0x63,0xa3,0x8d,0x6f,0xa2,0x56,0x13,0x69,0x74,0x69,
+0x90,0x62,0xa2,0xbe,0x63,0xa4,0x30,0x64,0xa4,0xfd,0x65,5,0x6d,0x63,0x6d,0x6e,
+0x70,0xa2,0x59,0x78,0x10,0x74,0x30,1,0x65,0x2c,0x70,0x12,0x69,0x63,0x74,0xa1,
+0x12,0x6e,0x64,0x65,1,0x64,0x24,0x72,0x31,0x1b,0x70,0x69,0x63,0x74,0x6f,0x67,
+0x72,0x61,0x70,0x68,0x69,0x63,0xa1,0x10,0x6f,1,0x64,0x97,0x6a,0x10,0x69,0x92,
+2,0x63,0x40,0x6d,0x50,0x70,0x1a,0x72,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,0x69,
+0x6f,0x6e,0x95,0x17,0x6f,0x6d,0x70,0x6f,0x6e,0x65,0x6e,0x74,0x9b,0x16,0x6f,0x64,
+0x69,0x66,0x69,0x65,0x72,0x96,0x13,0x62,0x61,0x73,0x65,0x99,0x12,0x72,0x65,0x73,
+0x95,0x61,0x30,0x62,0x4e,0x63,0x12,0x6f,0x6d,0x70,0x9b,0xc2,4,0x1b,0x73,0x74,
+0x61,0x73,0x69,0x61,0x6e,0x77,0x69,0x64,0x74,0x68,0xc3,4,0x12,0x61,0x73,0x65,
+0x99,3,0x67,0x44,0x68,0x4a,0x6c,0x4e,0x73,0x1a,0x63,0x69,0x69,0x68,0x65,0x78,
+0x64,0x69,0x67,0x69,0x74,0x23,0x10,0x65,0xd9,0x40,0,0x11,0x65,0x78,0x23,1,
+0x6e,0x38,0x70,0x11,0x68,0x61,0x20,0x14,0x62,0x65,0x74,0x69,0x63,0x21,0x11,0x75,
+0x6d,0x79,4,0x63,0xc3,0,0x69,0x3e,0x6c,0xa2,0x57,0x6d,0xa2,0x64,0x70,1,
+0x62,0xd9,0x40,0xd,0x74,0xc3,0x15,0x11,0x64,0x69,2,0x63,0x54,0x6d,0x74,0x70,
+0x1b,0x61,0x69,0x72,0x65,0x64,0x62,0x72,0x61,0x63,0x6b,0x65,0x74,0xd8,0x40,0xd,
+0x13,0x74,0x79,0x70,0x65,0xc3,0x15,0x24,1,0x6c,0x30,0x6f,0x14,0x6e,0x74,0x72,
+0x6f,0x6c,0x25,0x12,0x61,0x73,0x73,0xc3,0,0x26,0x14,0x69,0x72,0x72,0x6f,0x72,
+1,0x65,0x38,0x69,0x16,0x6e,0x67,0x67,0x6c,0x79,0x70,0x68,0xd9,0x40,1,0x10,
+0x64,0x27,2,0x61,0x32,0x6b,0xc3,1,0x6f,0x11,0x63,0x6b,0xc3,1,0x11,0x6e,
+0x6b,0x7b,0x10,0x67,0xd9,0x40,1,6,0x68,0x7c,0x68,0x54,0x69,0x85,0x6f,0xa2,
+0x6f,0x77,4,0x63,0x30,0x6b,0x36,0x6c,0x87,0x74,0x8b,0x75,0x89,1,0x66,0x8d,
+0x6d,0x8f,0x11,0x63,0x66,0x91,0x18,0x61,0x6e,0x67,0x65,0x73,0x77,0x68,0x65,0x6e,
+4,0x63,0x44,0x6c,0x6c,0x6e,0x7e,0x74,0x98,0x75,0x18,0x70,0x70,0x65,0x72,0x63,
+0x61,0x73,0x65,0x64,0x89,0x12,0x61,0x73,0x65,1,0x66,0x30,0x6d,0x14,0x61,0x70,
+0x70,0x65,0x64,0x8f,0x14,0x6f,0x6c,0x64,0x65,0x64,0x8d,0x18,0x6f,0x77,0x65,0x72,
+0x63,0x61,0x73,0x65,0x64,0x87,0x1c,0x66,0x6b,0x63,0x63,0x61,0x73,0x65,0x66,0x6f,
+0x6c,0x64,0x65,0x64,0x91,0x18,0x69,0x74,0x6c,0x65,0x63,0x61,0x73,0x65,0x64,0x8b,
+0x13,0x6d,0x70,0x65,0x78,0x33,0x61,0x2e,0x63,0xa2,0x48,0x66,0xd9,0x40,2,1,
+0x6e,0x72,0x73,0x10,0x65,3,0x64,0x83,0x66,0x3a,0x69,0x4a,0x73,0x17,0x65,0x6e,
+0x73,0x69,0x74,0x69,0x76,0x65,0x65,0x15,0x6f,0x6c,0x64,0x69,0x6e,0x67,0xd9,0x40,
+2,0x17,0x67,0x6e,0x6f,0x72,0x61,0x62,0x6c,0x65,0x85,0x13,0x6f,0x6e,0x69,0x63,
+0x1f,0x61,0x6c,0x63,0x6f,0x6d,0x62,0x69,0x6e,0x69,0x6e,0x67,0x63,0x6c,0x61,0x73,
+0x73,0xc3,2,0x10,0x63,0xc3,2,3,0x61,0x30,0x65,0x34,0x69,0xa2,0x41,0x74,
+0xc3,3,0x11,0x73,0x68,0x29,2,0x63,0x3a,0x66,0x58,0x70,0x2c,0x16,0x72,0x65,
+0x63,0x61,0x74,0x65,0x64,0x2d,0x1d,0x6f,0x6d,0x70,0x6f,0x73,0x69,0x74,0x69,0x6f,
+0x6e,0x74,0x79,0x70,0x65,0xc3,3,0x15,0x61,0x75,0x6c,0x74,0x69,0x67,0x1f,0x6e,
+0x6f,0x72,0x61,0x62,0x6c,0x65,0x63,0x6f,0x64,0x65,0x70,0x6f,0x69,0x6e,0x74,0x2b,
+0x2a,0x10,0x61,0x2e,0x15,0x63,0x72,0x69,0x74,0x69,0x63,0x2f,3,0x66,0x34,0x6e,
+0x3e,0x74,0x42,0x79,0x22,0x11,0x65,0x73,0x23,0x20,0x13,0x61,0x6c,0x73,0x65,0x21,
+0x20,0x10,0x6f,0x21,0x22,0x12,0x72,0x75,0x65,0x23,0xa,0x6b,0x5b,0x6f,0x23,0x6f,
+0x3c,0x72,0x4c,0x76,1,0x69,0x24,0x72,0x33,0x13,0x72,0x61,0x6d,0x61,0x33,0x10,
+0x76,0x22,0x14,0x65,0x72,0x6c,0x61,0x79,0x23,0xa2,0xe2,0x13,0x69,0x67,0x68,0x74,
+0xa3,0xe2,0x6b,0x58,0x6c,0x74,0x6e,3,0x6b,0x2f,0x6f,0x30,0x72,0x21,0x75,0x12,
+0x6b,0x74,0x61,0x2f,0x19,0x74,0x72,0x65,0x6f,0x72,0x64,0x65,0x72,0x65,0x64,0x21,
+1,0x61,0x24,0x76,0x31,0x18,0x6e,0x61,0x76,0x6f,0x69,0x63,0x69,0x6e,0x67,0x31,
+0xa2,0xe0,0x12,0x65,0x66,0x74,0xa3,0xe0,0x61,0x5c,0x62,0xa2,0x77,0x63,0xa2,0x96,
+0x64,0xa4,0xa,0x69,1,0x6f,0x26,0x73,0xa3,0xf0,0x1a,0x74,0x61,0x73,0x75,0x62,
+0x73,0x63,0x72,0x69,0x70,0x74,0xa3,0xf0,0xa2,0xe6,3,0x62,0xa0,0x6c,0xa3,0xe4,
+0x72,0xa3,0xe8,0x74,2,0x61,0x74,0x62,0x7c,0x74,0x14,0x61,0x63,0x68,0x65,0x64,
+1,0x61,0x3e,0x62,0x13,0x65,0x6c,0x6f,0x77,0xa2,0xca,0x13,0x6c,0x65,0x66,0x74,
+0xa3,0xc8,0x13,0x62,0x6f,0x76,0x65,0xa2,0xd6,0x14,0x72,0x69,0x67,0x68,0x74,0xa3,
+0xd8,0xa2,0xd6,0x10,0x72,0xa3,0xd8,0xa2,0xca,0x10,0x6c,0xa3,0xc8,0x12,0x6f,0x76,
+0x65,0xa2,0xe6,1,0x6c,0x30,0x72,0x13,0x69,0x67,0x68,0x74,0xa3,0xe8,0x12,0x65,
+0x66,0x74,0xa3,0xe4,0xa2,0xdc,2,0x65,0x2c,0x6c,0xa3,0xda,0x72,0xa3,0xde,0x12,
+0x6c,0x6f,0x77,0xa2,0xdc,1,0x6c,0x30,0x72,0x13,0x69,0x67,0x68,0x74,0xa3,0xde,
+0x12,0x65,0x66,0x74,0xa3,0xda,0x11,0x63,0x63,4,0x31,0x3c,0x32,0xa2,0x42,0x33,
+0xa2,0x56,0x38,0xa2,0x64,0x39,0x10,0x31,0xa3,0x5b,9,0x35,0xa,0x35,0x3f,0x36,
+0x41,0x37,0x43,0x38,0x45,0x39,0x47,0x30,0x30,0x31,0x3c,0x32,0x42,0x33,0x4e,0x34,
+0x3d,0x34,1,0x33,0xa3,0x67,0x37,0xa3,0x6b,0x36,0x10,0x38,0xa3,0x76,0x38,1,
+0x32,0xa3,0x7a,0x39,0xa3,0x81,0x3a,2,0x30,0xa3,0x82,0x32,0xa3,0x84,0x33,0xa3,
+0x85,9,0x35,0xa,0x35,0x53,0x36,0x55,0x37,0x57,0x38,0x59,0x39,0x5b,0x30,0x49,
+0x31,0x4b,0x32,0x4d,0x33,0x4f,0x34,0x51,6,0x33,8,0x33,0x63,0x34,0x65,0x35,
+0x67,0x36,0x69,0x30,0x5d,0x31,0x5f,0x32,0x61,0x10,0x34,0xa3,0x54,2,0x61,0xa3,
+0xea,0x62,0xa3,0xe9,0x6f,0x13,0x75,0x62,0x6c,0x65,1,0x61,0x30,0x62,0x13,0x65,
+0x6c,0x6f,0x77,0xa3,0xe9,0x13,0x62,0x6f,0x76,0x65,0xa3,0xea,0xb,0x6e,0xc0,0xca,
+0x72,0x5f,0x72,0x46,0x73,0xa2,0x48,0x77,1,0x68,0x24,0x73,0x33,0x17,0x69,0x74,
+0x65,0x73,0x70,0x61,0x63,0x65,0x33,0x22,1,0x69,0x30,0x6c,2,0x65,0x3d,0x69,
+0x4b,0x6f,0x3f,0x18,0x67,0x68,0x74,0x74,0x6f,0x6c,0x65,0x66,0x74,0x22,2,0x65,
+0x38,0x69,0x48,0x6f,0x16,0x76,0x65,0x72,0x72,0x69,0x64,0x65,0x3f,0x17,0x6d,0x62,
+0x65,0x64,0x64,0x69,0x6e,0x67,0x3d,0x15,0x73,0x6f,0x6c,0x61,0x74,0x65,0x4b,0x30,
+0x1e,0x65,0x67,0x6d,0x65,0x6e,0x74,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,
+0x31,0x6e,0xa2,0x41,0x6f,0xa2,0x53,0x70,2,0x61,0x66,0x64,0x86,0x6f,0x1b,0x70,
+0x64,0x69,0x72,0x65,0x63,0x74,0x69,0x6f,0x6e,0x61,0x6c,1,0x66,0x32,0x69,0x15,
+0x73,0x6f,0x6c,0x61,0x74,0x65,0x4d,0x14,0x6f,0x72,0x6d,0x61,0x74,0x41,0x1f,0x72,
+0x61,0x67,0x72,0x61,0x70,0x68,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x2f,
+1,0x66,0x41,0x69,0x4d,1,0x6f,0x28,0x73,0x10,0x6d,0x43,0x1b,0x6e,0x73,0x70,
+0x61,0x63,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,0x43,1,0x6e,0x35,0x74,0x19,0x68,
+0x65,0x72,0x6e,0x65,0x75,0x74,0x72,0x61,0x6c,0x35,0x65,0x88,0x65,0x98,0x66,0xa2,
+0x6a,0x6c,0x20,1,0x65,0x30,0x72,2,0x65,0x37,0x69,0x49,0x6f,0x39,0x18,0x66,
+0x74,0x74,0x6f,0x72,0x69,0x67,0x68,0x74,0x20,2,0x65,0x38,0x69,0x48,0x6f,0x16,
+0x76,0x65,0x72,0x72,0x69,0x64,0x65,0x39,0x17,0x6d,0x62,0x65,0x64,0x64,0x69,0x6e,
+0x67,0x37,0x15,0x73,0x6f,0x6c,0x61,0x74,0x65,0x49,3,0x6e,0x25,0x73,0x27,0x74,
+0x29,0x75,0x15,0x72,0x6f,0x70,0x65,0x61,0x6e,2,0x6e,0x3c,0x73,0x46,0x74,0x18,
+0x65,0x72,0x6d,0x69,0x6e,0x61,0x74,0x6f,0x72,0x29,0x14,0x75,0x6d,0x62,0x65,0x72,
+0x25,0x17,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x27,1,0x69,0x28,0x73,0x10,
+0x69,0x47,0x1f,0x72,0x73,0x74,0x73,0x74,0x72,0x6f,0x6e,0x67,0x69,0x73,0x6f,0x6c,
+0x61,0x74,0x65,0x47,0x61,0x4e,0x62,0x84,0x63,1,0x6f,0x24,0x73,0x2d,0x1c,0x6d,
+0x6d,0x6f,0x6e,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x2d,2,0x6c,0x3b,
+0x6e,0x2b,0x72,0x13,0x61,0x62,0x69,0x63,1,0x6c,0x30,0x6e,0x14,0x75,0x6d,0x62,
+0x65,0x72,0x2b,0x14,0x65,0x74,0x74,0x65,0x72,0x3b,0x2e,1,0x6e,0x45,0x6f,0x1c,
+0x75,0x6e,0x64,0x61,0x72,0x79,0x6e,0x65,0x75,0x74,0x72,0x61,0x6c,0x45,0,0x16,
+0x6d,0xc7,0xfe,0x74,0xc1,0xb8,0x77,0x57,0x77,0x48,0x79,0x5c,0x7a,0x1d,0x61,0x6e,
+0x61,0x62,0x61,0x7a,0x61,0x72,0x73,0x71,0x75,0x61,0x72,0x65,0xa5,0x18,0x18,0x61,
+0x72,0x61,0x6e,0x67,0x63,0x69,0x74,0x69,0xa3,0xfc,0x10,0x69,2,0x6a,0x3c,0x72,
+0x68,0x73,0x17,0x79,0x6c,0x6c,0x61,0x62,0x6c,0x65,0x73,0xa3,0x48,0x12,0x69,0x6e,
+0x67,0xa2,0x74,0x1e,0x68,0x65,0x78,0x61,0x67,0x72,0x61,0x6d,0x73,0x79,0x6d,0x62,
+0x6f,0x6c,0x73,0xa3,0x74,0x16,0x61,0x64,0x69,0x63,0x61,0x6c,0x73,0xa3,0x49,0x74,
+0xa2,0x59,0x75,0xa4,0x12,0x76,2,0x61,0x36,0x65,0x7a,0x73,0xa2,0x6c,0x12,0x73,
+0x75,0x70,0xa3,0x7d,1,0x69,0xa3,0x9f,0x72,0x1e,0x69,0x61,0x74,0x69,0x6f,0x6e,
+0x73,0x65,0x6c,0x65,0x63,0x74,0x6f,0x72,0x73,0xa2,0x6c,0x19,0x73,0x75,0x70,0x70,
+0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x7d,1,0x64,0x3c,0x72,0x19,0x74,0x69,0x63,
+0x61,0x6c,0x66,0x6f,0x72,0x6d,0x73,0xa3,0x91,0x14,0x69,0x63,0x65,0x78,0x74,0xa2,
+0xaf,0x16,0x65,0x6e,0x73,0x69,0x6f,0x6e,0x73,0xa3,0xaf,4,0x61,0x68,0x65,0xa2,
+0x8a,0x68,0xa2,0x8d,0x69,0xa2,0x95,0x72,0x1c,0x61,0x6e,0x73,0x70,0x6f,0x72,0x74,
+0x61,0x6e,0x64,0x6d,0x61,0x70,0xa2,0xcf,0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,
+0xa3,0xcf,4,0x67,0x58,0x69,0x7e,0x6b,0xa2,0x58,0x6d,0xa2,0x5a,0x6e,0x12,0x67,
+0x75,0x74,0xa4,0x10,0x19,0x63,0x6f,0x6d,0x70,0x6f,0x6e,0x65,0x6e,0x74,0x73,0xa5,
+0x11,2,0x61,0x2a,0x62,0x32,0x73,0xa3,0x60,0x12,0x6c,0x6f,0x67,0xa3,0x62,0x13,
+0x61,0x6e,0x77,0x61,0xa3,0x65,3,0x6c,0x52,0x74,0x56,0x76,0x5e,0x78,0x16,0x75,
+0x61,0x6e,0x6a,0x69,0x6e,0x67,0xa2,0x7c,0x16,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,
+0xa3,0x7c,0x10,0x65,0xa3,0x70,0x12,0x68,0x61,0x6d,0xa3,0xae,0x12,0x69,0x65,0x74,
+0xa3,0xb7,0x11,0x72,0x69,0xa3,0xdc,0x11,0x69,0x6c,0x49,0x13,0x6c,0x75,0x67,0x75,
+0x4b,0x10,0x61,1,0x61,0x24,0x69,0x53,0x11,0x6e,0x61,0x3d,2,0x62,0x34,0x66,
+0x3c,0x72,0x13,0x68,0x75,0x74,0x61,0xa3,0xfb,0x13,0x65,0x74,0x61,0x6e,0x57,0x14,
+0x69,0x6e,0x61,0x67,0x68,0xa3,0x90,2,0x63,0x82,0x67,0x92,0x6e,0x1f,0x69,0x66,
+0x69,0x65,0x64,0x63,0x61,0x6e,0x61,0x64,0x69,0x61,0x6e,0x61,0x62,0x6f,0x1f,0x72,
+0x69,0x67,0x69,0x6e,0x61,0x6c,0x73,0x79,0x6c,0x6c,0x61,0x62,0x69,0x63,0x73,0x62,
+0x17,0x65,0x78,0x74,0x65,0x6e,0x64,0x65,0x64,0xa3,0xad,0x11,0x61,0x73,0x62,0x12,
+0x65,0x78,0x74,0xa3,0xad,0x15,0x61,0x72,0x69,0x74,0x69,0x63,0xa3,0x78,0x70,0xc2,
+0xf5,0x70,0xa6,0xb,0x72,0xa6,0xc7,0x73,7,0x6f,0xc1,0x7f,0x6f,0x76,0x70,0xa2,
+0x47,0x75,0xa2,0x66,0x79,1,0x6c,0x4c,0x72,0x12,0x69,0x61,0x63,0x3a,0x12,0x73,
+0x75,0x70,0xa4,0x17,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa5,0x17,0x17,0x6f,
+0x74,0x69,0x6e,0x61,0x67,0x72,0x69,0xa3,0x8f,2,0x67,0x34,0x72,0x3e,0x79,0x13,
+0x6f,0x6d,0x62,0x6f,0xa5,0x16,0x13,0x64,0x69,0x61,0x6e,0xa5,0x23,0x17,0x61,0x73,
+0x6f,0x6d,0x70,0x65,0x6e,0x67,0xa3,0xda,1,0x61,0x32,0x65,0x14,0x63,0x69,0x61,
+0x6c,0x73,0xa3,0x56,0x12,0x63,0x69,0x6e,0x1f,0x67,0x6d,0x6f,0x64,0x69,0x66,0x69,
+0x65,0x72,0x6c,0x65,0x74,0x74,0x65,0x72,0x73,0x2d,2,0x6e,0x48,0x70,0x76,0x74,
+0x1d,0x74,0x6f,0x6e,0x73,0x69,0x67,0x6e,0x77,0x72,0x69,0x74,0x69,0x6e,0x67,0xa5,
+6,0x15,0x64,0x61,0x6e,0x65,0x73,0x65,0xa2,0x9b,0x12,0x73,0x75,0x70,0xa2,0xdb,
+0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xdb,4,0x61,0xa2,0xa8,0x65,0x5c,
+0x6d,0x9e,0x70,0xa2,0x4b,0x73,0x13,0x79,0x6d,0x62,0x6f,0x1f,0x6c,0x73,0x61,0x6e,
+0x64,0x70,0x69,0x63,0x74,0x6f,0x67,0x72,0x61,0x70,0x68,0x73,0xa5,5,0x10,0x72,
+1,0x61,0x4e,0x73,0x12,0x63,0x72,0x69,0x1f,0x70,0x74,0x73,0x61,0x6e,0x64,0x73,
+0x75,0x62,0x73,0x63,0x72,0x69,0x70,0x74,0x73,0x73,0x14,0x6e,0x64,0x73,0x75,0x62,
+0x73,0x1b,0x61,0x74,0x68,0x6f,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,0xa3,0x6a,
+1,0x6c,0x40,0x75,1,0x61,0x6e,0x6e,0x17,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,
+0x6e,0xa3,0x8e,0x15,0x65,0x6d,0x65,0x6e,0x74,0x61,1,0x6c,0x50,0x72,0x1e,0x79,
+0x70,0x72,0x69,0x76,0x61,0x74,0x65,0x75,0x73,0x65,0x61,0x72,0x65,0x61,1,0x61,
+0xa3,0x6d,0x62,0xa3,0x6e,3,0x61,0x5c,0x6d,0x78,0x70,0xa2,0x41,0x73,0x13,0x79,
+0x6d,0x62,0x6f,0x1f,0x6c,0x73,0x61,0x6e,0x64,0x70,0x69,0x63,0x74,0x6f,0x67,0x72,
+0x61,0x70,0x68,0x73,0xa5,5,0x14,0x72,0x72,0x6f,0x77,0x73,2,0x61,0xa3,0x67,
+0x62,0xa3,0x68,0x63,0xa3,0xfa,0x13,0x61,0x74,0x68,0x65,0x1f,0x6d,0x61,0x74,0x69,
+0x63,0x61,0x6c,0x6f,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,0xa3,0x6a,0x19,0x75,
+0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xa3,0x8e,0x61,0x5a,0x68,0x84,0x69,
+0xa2,0x5b,0x6d,0x16,0x61,0x6c,0x6c,0x66,0x6f,0x72,0x6d,1,0x73,0xa3,0x54,0x76,
+0x16,0x61,0x72,0x69,0x61,0x6e,0x74,0x73,0xa3,0x54,1,0x6d,0x36,0x75,0x16,0x72,
+0x61,0x73,0x68,0x74,0x72,0x61,0xa3,0xa1,0x15,0x61,0x72,0x69,0x74,0x61,0x6e,0xa3,
+0xac,1,0x61,0x52,0x6f,0x13,0x72,0x74,0x68,0x61,0x1f,0x6e,0x64,0x66,0x6f,0x72,
+0x6d,0x61,0x74,0x63,0x6f,0x6e,0x74,0x72,0x6f,0x6c,0x73,0xa3,0xf7,1,0x72,0x2e,
+0x76,0x12,0x69,0x61,0x6e,0xa3,0x79,0x12,0x61,0x64,0x61,0xa3,0xd9,1,0x64,0x50,
+0x6e,0x13,0x68,0x61,0x6c,0x61,0x50,0x1d,0x61,0x72,0x63,0x68,0x61,0x69,0x63,0x6e,
+0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0xf9,0x13,0x64,0x68,0x61,0x6d,0xa3,0xf8,5,
+0x72,0x35,0x72,0x44,0x73,0x64,0x75,1,0x61,0xa3,0x4e,0x6e,0x17,0x63,0x74,0x75,
+0x61,0x74,0x69,0x6f,0x6e,0x71,0x17,0x69,0x76,0x61,0x74,0x65,0x75,0x73,0x65,0xa2,
+0x4e,0x13,0x61,0x72,0x65,0x61,0xa3,0x4e,0x1b,0x61,0x6c,0x74,0x65,0x72,0x70,0x61,
+0x68,0x6c,0x61,0x76,0x69,0xa3,0xf6,0x61,0x40,0x68,0x82,0x6c,0x19,0x61,0x79,0x69,
+0x6e,0x67,0x63,0x61,0x72,0x64,0x73,0xa3,0xcc,2,0x68,0x38,0x6c,0x4a,0x75,0x15,
+0x63,0x69,0x6e,0x68,0x61,0x75,0xa3,0xf5,0x17,0x61,0x77,0x68,0x68,0x6d,0x6f,0x6e,
+0x67,0xa3,0xf3,0x15,0x6d,0x79,0x72,0x65,0x6e,0x65,0xa3,0xf4,1,0x61,0x8e,0x6f,
+1,0x65,0x74,0x6e,0x16,0x65,0x74,0x69,0x63,0x65,0x78,0x74,0xa2,0x72,1,0x65,
+0x2c,0x73,0x11,0x75,0x70,0xa3,0x8d,0x15,0x6e,0x73,0x69,0x6f,0x6e,0x73,0xa2,0x72,
+0x19,0x73,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x8d,0x15,0x6e,0x69,
+0x63,0x69,0x61,0x6e,0xa3,0x97,1,0x67,0x3e,0x69,0x13,0x73,0x74,0x6f,0x73,0xa2,
+0xa6,0x13,0x64,0x69,0x73,0x63,0xa3,0xa6,0x12,0x73,0x70,0x61,0xa3,0x96,1,0x65,
+0x5c,0x75,1,0x6d,0x2a,0x6e,0x11,0x69,0x63,0x67,0x10,0x69,0xa2,0xc0,0x1d,0x6e,
+0x75,0x6d,0x65,0x72,0x61,0x6c,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xc0,0x13,
+0x6a,0x61,0x6e,0x67,0xa3,0xa3,0x6d,0xa2,0xce,0x6e,0xa8,1,0x6f,5,0x70,0x4b,
+0x70,0x46,0x72,0x7a,0x73,1,0x61,0x30,0x6d,0x13,0x61,0x6e,0x79,0x61,0xa3,0x7a,
+0x11,0x67,0x65,0xa5,0xf,0x18,0x74,0x69,0x63,0x61,0x6c,0x63,0x68,0x61,0x72,0x1f,
+0x61,0x63,0x74,0x65,0x72,0x72,0x65,0x63,0x6f,0x67,0x6e,0x69,0x74,0x69,0x6f,0x6e,
+0x85,1,0x69,0x46,0x6e,0x1e,0x61,0x6d,0x65,0x6e,0x74,0x61,0x6c,0x64,0x69,0x6e,
+0x67,0x62,0x61,0x74,0x73,0xa3,0xf2,0x11,0x79,0x61,0x47,0x63,0xa2,0x71,0x67,0xa2,
+0x71,0x6c,1,0x63,0xa2,0x62,0x64,5,0x70,0x38,0x70,0x36,0x73,0x56,0x74,0x14,
+0x75,0x72,0x6b,0x69,0x63,0xa3,0xbf,0x11,0x65,0x72,1,0x6d,0x2e,0x73,0x12,0x69,
+0x61,0x6e,0xa3,0x8c,0x11,0x69,0x63,0xa3,0xf1,0x10,0x6f,1,0x67,0x3a,0x75,0x18,
+0x74,0x68,0x61,0x72,0x61,0x62,0x69,0x61,0x6e,0xa3,0xbb,0x13,0x64,0x69,0x61,0x6e,
+0xa5,0x22,0x68,0x42,0x69,0x54,0x6e,0x1a,0x6f,0x72,0x74,0x68,0x61,0x72,0x61,0x62,
+0x69,0x61,0x6e,0xa3,0xf0,0x17,0x75,0x6e,0x67,0x61,0x72,0x69,0x61,0x6e,0xa5,4,
+0x14,0x74,0x61,0x6c,0x69,0x63,0xa3,0x58,0x13,0x68,0x69,0x6b,0x69,0xa3,0x9d,0x10,
+0x72,0x85,0x12,0x68,0x61,0x6d,0x65,6,0x6f,0x86,0x6f,0x6c,0x72,0xa2,0x61,0x75,
+0xa2,0x62,0x79,0x14,0x61,0x6e,0x6d,0x61,0x72,0x58,0x12,0x65,0x78,0x74,2,0x61,
+0xa3,0xb6,0x62,0xa3,0xee,0x65,0x13,0x6e,0x64,0x65,0x64,1,0x61,0xa3,0xb6,0x62,
+0xa3,0xee,1,0x64,0x52,0x6e,0x15,0x67,0x6f,0x6c,0x69,0x61,0x6e,0x6a,0x12,0x73,
+0x75,0x70,0xa4,0xd,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa5,0xd,0x10,0x69,
+0xa2,0xec,0x13,0x66,0x69,0x65,0x72,1,0x6c,0x3c,0x74,0x19,0x6f,0x6e,0x65,0x6c,
+0x65,0x74,0x74,0x65,0x72,0x73,0xa3,0x8a,0x15,0x65,0x74,0x74,0x65,0x72,0x73,0x2d,
+0x10,0x6f,0xa3,0xed,1,0x6c,0x44,0x73,0x11,0x69,0x63,0xa2,0x5c,0x18,0x61,0x6c,
+0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5c,0x13,0x74,0x61,0x6e,0x69,0xa5,3,
+0x61,0xa2,0x9b,0x65,0xa4,0x4c,0x69,1,0x61,0xa2,0x8f,0x73,0x10,0x63,5,0x70,
+0x18,0x70,0xa2,0x71,0x73,0x36,0x74,0x17,0x65,0x63,0x68,0x6e,0x69,0x63,0x61,0x6c,
+0x81,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x8f,0x61,0xa2,0x66,0x65,0x46,0x6d,0x19,
+0x61,0x74,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,1,0x61,0xa3,0x66,0x62,0xa3,
+0x69,0x17,0x6c,0x6c,0x61,0x6e,0x65,0x6f,0x75,0x73,2,0x6d,0x3a,0x73,0x6c,0x74,
+0x17,0x65,0x63,0x68,0x6e,0x69,0x63,0x61,0x6c,0x81,0x11,0x61,0x74,0x1f,0x68,0x65,
+0x6d,0x61,0x74,0x69,0x63,0x61,0x6c,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,1,0x61,
+0xa3,0x66,0x62,0xa3,0x69,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x8e,0x12,0x61,0x6e,
+0x64,1,0x61,0x3c,0x70,0x19,0x69,0x63,0x74,0x6f,0x67,0x72,0x61,0x70,0x68,0x73,
+0xa3,0xcd,0x14,0x72,0x72,0x6f,0x77,0x73,0xa3,0x73,0x10,0x6f,0xa3,0xd8,7,0x72,
+0x6f,0x72,0x44,0x73,0x4e,0x74,0x62,0x79,0x19,0x61,0x6e,0x6e,0x75,0x6d,0x65,0x72,
+0x61,0x6c,0x73,0xa5,0x20,0x13,0x63,0x68,0x65,0x6e,0xa5,0xc,0x18,0x61,0x72,0x61,
+0x6d,0x67,0x6f,0x6e,0x64,0x69,0xa5,0x14,0x10,0x68,2,0x61,0x3a,0x65,0x4a,0x6f,
+0x17,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,0x7f,0x16,0x6c,0x70,0x68,0x61,0x6e,
+0x75,0x6d,0xa3,0x5d,0x16,0x6d,0x61,0x74,0x69,0x63,0x61,0x6c,1,0x61,0x36,0x6f,
+0x17,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,0x73,0x7f,0x11,0x6c,0x70,0x1f,0x68,0x61,
+0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5d,
+0x68,0x50,0x6b,0x7e,0x6c,0x88,0x6e,1,0x64,0x34,0x69,0x15,0x63,0x68,0x61,0x65,
+0x61,0x6e,0xa3,0xea,0x12,0x61,0x69,0x63,0xa3,0xc6,1,0x61,0x3e,0x6a,0x12,0x6f,
+0x6e,0x67,0xa2,0xaa,0x14,0x74,0x69,0x6c,0x65,0x73,0xa3,0xaa,0x13,0x6a,0x61,0x6e,
+0x69,0xa3,0xe9,0x13,0x61,0x73,0x61,0x72,0xa5,0x1f,0x15,0x61,0x79,0x61,0x6c,0x61,
+0x6d,0x4f,3,0x64,0x6c,0x65,0x7e,0x6e,0xa2,0x47,0x72,0x14,0x6f,0x69,0x74,0x69,
 0x63,1,0x63,0x3c,0x68,0x19,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,0x68,0x73,
-0xa3,0x56,0x15,0x75,0x72,0x73,0x69,0x76,0x65,0xa3,0x8d,0x17,0x74,0x65,0x69,0x6d,
-0x61,0x79,0x65,0x6b,0xa3,0x73,0x10,0x64,0xa2,0x8c,0x17,0x65,0x6b,0x69,0x6b,0x61,
-0x6b,0x75,0x69,0xa3,0x8c,0x11,0x61,0x6f,0xa3,0x5c,5,0x6f,0x14,0x6f,0x30,0x70,
-0x36,0x74,0x11,0x68,0x69,0xa3,0x78,0x11,0x72,0x65,0xa3,0x77,0x11,0x65,0x6c,0xa3,
-0x8a,0x61,0x2e,0x68,0x98,0x6e,0x11,0x64,0x61,0x4b,4,0x69,0x3c,0x6c,0x44,0x6e,
-0x48,0x74,0x56,0x79,0x13,0x61,0x68,0x6c,0x69,0xa3,0x4f,0x12,0x74,0x68,0x69,0xa3,
-0x78,0x10,0x69,0xa3,0x4f,1,0x61,0x4d,0x6e,0x12,0x61,0x64,0x61,0x4b,0x14,0x61,
-0x6b,0x61,0x6e,0x61,0x4c,0x19,0x6f,0x72,0x68,0x69,0x72,0x61,0x67,0x61,0x6e,0x61,
-0x8d,3,0x61,0x3c,0x6d,0x4e,0x6f,0x5a,0x75,0x15,0x64,0x61,0x77,0x61,0x64,0x69,
-0xa3,0x91,0x10,0x72,0x92,0x15,0x6f,0x73,0x68,0x74,0x68,0x69,0x93,1,0x65,0x24,
-0x72,0x4f,0x10,0x72,0x4f,0x10,0x6a,0xa2,0x9d,0x11,0x6b,0x69,0xa3,0x9d,4,0x61,
-0x5c,0x65,0x90,0x69,0xa0,0x6f,0xa2,0x5d,0x79,1,0x63,0x34,0x64,0x10,0x69,0xa2,
-0x6c,0x11,0x61,0x6e,0xa3,0x6c,0x10,0x69,0xa2,0x6b,0x11,0x61,0x6e,0xa3,0x6b,2,
-0x6e,0x42,0x6f,0x46,0x74,3,0x66,0xa3,0x50,0x67,0xa3,0x51,0x69,0x24,0x6e,0x53,
-0x10,0x6e,0x53,0x10,0x61,0xa3,0x6a,0x50,0x10,0x6f,0x51,0x11,0x70,0x63,0xa2,0x52,
-0x11,0x68,0x61,0xa3,0x52,2,0x6d,0x2e,0x6e,0x36,0x73,0x10,0x75,0xa3,0x83,0x10,
-0x62,0x80,0x10,0x75,0x81,2,0x61,0xa3,0x53,0x62,0x83,0x65,0x11,0x61,0x72,1,
-0x61,0xa3,0x53,0x62,0x83,0x11,0x6d,0x61,0xa3,0x8b,0x68,0x6e,0x69,0xa2,0x83,0x6a,
-2,0x61,0x30,0x70,0x52,0x75,0x11,0x72,0x63,0xa3,0x94,1,0x6d,0x38,0x76,0x10,
-0x61,0xa2,0x4e,0x13,0x6e,0x65,0x73,0x65,0xa3,0x4e,0x10,0x6f,0xa3,0xad,0x11,0x61,
-0x6e,0xa3,0x69,6,0x6c,0x1a,0x6c,0x34,0x6d,0x3a,0x72,0x40,0x75,0x11,0x6e,0x67,
-0xa3,0x4c,0x11,0x75,0x77,0xa3,0x9c,0x11,0x6e,0x67,0xa3,0x4b,0x11,0x6b,0x74,0x8d,
-0x61,0x3a,0x65,0x8c,0x69,0x11,0x72,0x61,0x48,0x13,0x67,0x61,0x6e,0x61,0x49,1,
-0x6e,0x34,0x74,0x10,0x72,0xa2,0xa2,0x11,0x61,0x6e,0xa3,0xa2,0x42,6,0x6f,0xe,
-0x6f,0x77,0x73,0xa3,0x49,0x74,0xa3,0x4a,0x75,0x12,0x6e,0x6f,0x6f,0x77,0x62,0xa3,
-0xac,0x67,0x24,0x69,0x43,0x44,0x11,0x75,0x6c,0x45,0x11,0x62,0x72,0x46,0x11,0x65,
-0x77,0x47,2,0x6d,0x2e,0x6e,0x4a,0x74,0x11,0x61,0x6c,0x5d,0x1c,0x70,0x65,0x72,
-0x69,0x61,0x6c,0x61,0x72,0x61,0x6d,0x61,0x69,0x63,0xa3,0x74,2,0x64,0x66,0x68,
-0x6a,0x73,0x1b,0x63,0x72,0x69,0x70,0x74,0x69,0x6f,0x6e,0x61,0x6c,0x70,0x61,1,
-0x68,0x32,0x72,0x14,0x74,0x68,0x69,0x61,0x6e,0xa3,0x7d,0x13,0x6c,0x61,0x76,0x69,
-0xa3,0x7a,0x10,0x73,0xa3,0x4d,0x15,0x65,0x72,0x69,0x74,0x65,0x64,0x23,0x64,0xc0,
-0xcf,0x64,0xa2,0x68,0x65,0xa2,0x90,0x67,4,0x65,0x64,0x6c,0x7c,0x6f,0x90,0x72,
-0xa2,0x44,0x75,1,0x6a,0x38,0x72,1,0x6d,0x24,0x75,0x41,0x13,0x75,0x6b,0x68,
-0x69,0x41,1,0x61,0x24,0x72,0x3f,0x13,0x72,0x61,0x74,0x69,0x3f,0x10,0x6f,1,
-0x6b,0xa3,0x48,0x72,0x38,0x13,0x67,0x69,0x61,0x6e,0x39,0x11,0x61,0x67,0x90,0x15,
-0x6f,0x6c,0x69,0x74,0x69,0x63,0x91,1,0x6e,0x30,0x74,0x10,0x68,0x3a,0x11,0x69,
-0x63,0x3b,0x10,0x6d,0xa3,0xaf,1,0x61,0x32,0x65,1,0x65,0x24,0x6b,0x3d,0x10,
-0x6b,0x3d,0x10,0x6e,0xa2,0x89,0x12,0x74,0x68,0x61,0xa3,0x89,2,0x65,0x3e,0x73,
-0x64,0x75,0x11,0x70,0x6c,0xa2,0x87,0x13,0x6f,0x79,0x61,0x6e,0xa3,0x87,1,0x73,
-0x38,0x76,0x10,0x61,0x34,0x15,0x6e,0x61,0x67,0x61,0x72,0x69,0x35,0x13,0x65,0x72,
-0x65,0x74,0x33,0x11,0x72,0x74,0x33,2,0x67,0x3a,0x6c,0x72,0x74,0x11,0x68,0x69,
-0x36,0x13,0x6f,0x70,0x69,0x63,0x37,0x10,0x79,2,0x64,0xa3,0x45,0x68,0xa3,0x46,
-0x70,0xa2,0x47,0x1e,0x74,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,
-0x70,0x68,0x73,0xa3,0x47,0x11,0x62,0x61,0xa2,0x88,0x12,0x73,0x61,0x6e,0xa3,0x88,
-0x61,0xa2,0xa2,0x62,0xa4,7,0x63,6,0x6f,0x3d,0x6f,0x5a,0x70,0x76,0x75,0x7a,
-0x79,1,0x70,0x3e,0x72,2,0x69,0x2a,0x6c,0x31,0x73,0xa3,0x44,0x13,0x6c,0x6c,
-0x69,0x63,0x31,0x13,0x72,0x69,0x6f,0x74,0x7f,1,0x6d,0x30,0x70,0x10,0x74,0x2e,
-0x11,0x69,0x63,0x2f,0x12,0x6d,0x6f,0x6e,0x21,0x11,0x72,0x74,0x7f,0x16,0x6e,0x65,
-0x69,0x66,0x6f,0x72,0x6d,0xa3,0x65,0x61,0x32,0x68,0xa2,0x41,0x69,0x11,0x72,0x74,
-0xa3,0x43,3,0x6b,0x4c,0x6e,0x50,0x72,0x76,0x75,0x1d,0x63,0x61,0x73,0x69,0x61,
-0x6e,0x61,0x6c,0x62,0x61,0x6e,0x69,0x61,0x6e,0xa3,0x9f,0x10,0x6d,0xa3,0x76,1,
-0x61,0x24,0x73,0x71,0x1d,0x64,0x69,0x61,0x6e,0x61,0x62,0x6f,0x72,0x69,0x67,0x69,
-0x6e,0x61,0x6c,0x71,0x10,0x69,0xa2,0x68,0x11,0x61,0x6e,0xa3,0x68,1,0x61,0x34,
-0x65,0x10,0x72,0x2c,0x13,0x6f,0x6b,0x65,0x65,0x2d,1,0x6b,0x26,0x6d,0xa3,0x42,
-0x11,0x6d,0x61,0xa3,0x76,6,0x68,0x4a,0x68,0x48,0x6e,0x4e,0x72,0x76,0x76,1,
-0x65,0x2a,0x73,0x10,0x74,0xa3,0x75,0x13,0x73,0x74,0x61,0x6e,0xa3,0x75,0x11,0x6f,
-0x6d,0xa3,0xa1,0x11,0x61,0x74,0x1f,0x6f,0x6c,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,
-0x6f,0x67,0x6c,0x79,0x70,0x68,0x73,0xa3,0x9c,1,0x61,0x3e,0x6d,2,0x65,0x2a,
-0x69,0xa3,0x74,0x6e,0x27,0x13,0x6e,0x69,0x61,0x6e,0x27,0x10,0x62,0x24,0x11,0x69,
-0x63,0x25,0x64,0x30,0x66,0x44,0x67,0x11,0x68,0x62,0xa3,0x9f,0x10,0x6c,1,0x61,
-0x26,0x6d,0xa3,0xa7,0x10,0x6d,0xa3,0xa7,0x11,0x61,0x6b,0xa3,0x93,6,0x6c,0x3c,
-0x6c,0x52,0x6f,0x56,0x72,0x66,0x75,1,0x67,0x30,0x68,1,0x64,0x79,0x69,0x10,
-0x64,0x79,0x10,0x69,0x8e,0x13,0x6e,0x65,0x73,0x65,0x8f,0x11,0x69,0x73,0xa1,0x11,
-0x70,0x6f,0x2a,0x13,0x6d,0x6f,0x66,0x6f,0x2b,0x10,0x61,1,0x68,0x2e,0x69,0x7c,
-0x12,0x6c,0x6c,0x65,0x7d,0xa2,0x41,0x11,0x6d,0x69,0xa3,0x41,0x61,0x48,0x65,0x9c,
-0x68,1,0x61,0x2a,0x6b,0x10,0x73,0xa3,0xa8,0x15,0x69,0x6b,0x73,0x75,0x6b,0x69,
-0xa3,0xa8,3,0x6c,0x3a,0x6d,0x48,0x73,0x54,0x74,1,0x61,0x24,0x6b,0x9f,0x10,
-0x6b,0x9f,0x10,0x69,0x9c,0x13,0x6e,0x65,0x73,0x65,0x9d,0x10,0x75,0xa2,0x82,0x10,
-0x6d,0xa3,0x82,0x10,0x73,0xa2,0x86,0x13,0x61,0x76,0x61,0x68,0xa3,0x86,0x11,0x6e,
-0x67,0x28,0x12,0x61,0x6c,0x69,0x29,3,0x6c,0x42,0x6e,0x90,0x74,0xa2,0x46,0x76,
-0x24,0x17,0x6f,0x77,0x65,0x6c,0x6a,0x61,0x6d,0x6f,0x25,0x22,1,0x65,0x54,0x76,
-0x28,1,0x73,0x38,0x74,0x2a,0x17,0x73,0x79,0x6c,0x6c,0x61,0x62,0x6c,0x65,0x2b,
-0x16,0x79,0x6c,0x6c,0x61,0x62,0x6c,0x65,0x29,0x18,0x61,0x64,0x69,0x6e,0x67,0x6a,
-0x61,0x6d,0x6f,0x23,1,0x61,0x21,0x6f,0x1a,0x74,0x61,0x70,0x70,0x6c,0x69,0x63,
-0x61,0x62,0x6c,0x65,0x21,0x26,0x1a,0x72,0x61,0x69,0x6c,0x69,0x6e,0x67,0x6a,0x61,
-0x6d,0x6f,0x27,1,0x6e,0x2c,0x79,0x22,0x11,0x65,0x73,0x23,0x20,0x10,0x6f,0x21,
-1,0x6e,0x2c,0x79,0x22,0x11,0x65,0x73,0x23,0x20,0x10,0x6f,0x21,2,0x6d,0x30,
-0x6e,0x3a,0x79,0x22,0x11,0x65,0x73,0x23,0x24,0x13,0x61,0x79,0x62,0x65,0x25,0x20,
-0x10,0x6f,0x21,2,0x6d,0x30,0x6e,0x3a,0x79,0x22,0x11,0x65,0x73,0x23,0x24,0x13,
-0x61,0x79,0x62,0x65,0x25,0x20,0x10,0x6f,0x21,0xb,0x72,0x39,0x76,0xc,0x76,0x33,
-0x78,0x2a,0x7a,0x11,0x77,0x6a,0x43,0x10,0x78,0x21,0x72,0x28,0x73,0x50,0x74,0x31,
-1,0x65,0x24,0x69,0x39,0x1e,0x67,0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,
-0x63,0x61,0x74,0x6f,0x72,0x39,1,0x6d,0x35,0x70,0x18,0x61,0x63,0x69,0x6e,0x67,
-0x6d,0x61,0x72,0x6b,0x35,0x6c,0x1f,0x6c,0x3c,0x6f,0x4a,0x70,1,0x70,0x37,0x72,
-0x14,0x65,0x70,0x65,0x6e,0x64,0x37,0x28,1,0x66,0x2b,0x76,0x2c,0x10,0x74,0x2f,
-0x13,0x74,0x68,0x65,0x72,0x21,0x63,0x4c,0x65,0x64,0x67,1,0x61,0x3a,0x6c,0x19,
-0x75,0x65,0x61,0x66,0x74,0x65,0x72,0x7a,0x77,0x6a,0x41,0x10,0x7a,0x41,2,0x6e,
-0x23,0x6f,0x24,0x72,0x25,0x14,0x6e,0x74,0x72,0x6f,0x6c,0x23,2,0x62,0x34,0x6d,
-0x4e,0x78,0x26,0x13,0x74,0x65,0x6e,0x64,0x27,0x3a,1,0x61,0x24,0x67,0x3d,0x11,
-0x73,0x65,0x3a,0x12,0x67,0x61,0x7a,0x3d,0x3e,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,
-0x72,0x3f,9,0x6e,0x4a,0x6e,0x34,0x6f,0x44,0x73,0x60,0x75,0x94,0x78,0x10,0x78,
-0x21,0x10,0x75,0x2a,0x14,0x6d,0x65,0x72,0x69,0x63,0x2b,1,0x6c,0x2c,0x74,0x12,
-0x68,0x65,0x72,0x21,0x14,0x65,0x74,0x74,0x65,0x72,0x2d,3,0x63,0x36,0x65,0x46,
-0x70,0x31,0x74,0x32,0x12,0x65,0x72,0x6d,0x33,0x3c,0x16,0x6f,0x6e,0x74,0x69,0x6e,
-0x75,0x65,0x3d,0x2e,0x10,0x70,0x2f,0x10,0x70,0x34,0x12,0x70,0x65,0x72,0x35,0x61,
-0x46,0x63,0x52,0x65,0x64,0x66,0x72,0x6c,2,0x65,0x2d,0x66,0x3b,0x6f,0x28,0x12,
-0x77,0x65,0x72,0x29,0x10,0x74,0x22,0x12,0x65,0x72,0x6d,0x23,1,0x6c,0x24,0x72,
-0x37,0x24,0x12,0x6f,0x73,0x65,0x25,0x10,0x78,0x38,0x13,0x74,0x65,0x6e,0x64,0x39,
-0x10,0x6f,0x26,0x13,0x72,0x6d,0x61,0x74,0x27,0xf,0x6c,0x7c,0x72,0x34,0x72,0x32,
-0x73,0x5a,0x78,0x76,0x7a,0x11,0x77,0x6a,0x4b,1,0x65,0x24,0x69,0x3b,0x1e,0x67,
-0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,0x63,0x61,0x74,0x6f,0x72,0x3b,1,
-0x69,0x24,0x71,0x3f,0x18,0x6e,0x67,0x6c,0x65,0x71,0x75,0x6f,0x74,0x65,0x3f,0x10,
-0x78,0x21,0x6c,0x36,0x6d,0x3c,0x6e,0x76,0x6f,0x13,0x74,0x68,0x65,0x72,0x21,1,
-0x65,0x23,0x66,0x35,3,0x62,0x37,0x69,0x28,0x6c,0x29,0x6e,0x2b,0x10,0x64,1,
-0x6c,0x34,0x6e,0x11,0x75,0x6d,0x2a,0x12,0x6c,0x65,0x74,0x37,0x14,0x65,0x74,0x74,
-0x65,0x72,0x29,2,0x65,0x36,0x6c,0x39,0x75,0x2c,0x14,0x6d,0x65,0x72,0x69,0x63,
-0x2d,0x14,0x77,0x6c,0x69,0x6e,0x65,0x39,0x66,0x3f,0x66,0x40,0x67,0x4e,0x68,0x70,
-0x6b,0x10,0x61,0x26,0x15,0x74,0x61,0x6b,0x61,0x6e,0x61,0x27,0x10,0x6f,0x24,0x13,
-0x72,0x6d,0x61,0x74,0x25,1,0x61,0x3a,0x6c,0x19,0x75,0x65,0x61,0x66,0x74,0x65,
-0x72,0x7a,0x77,0x6a,0x49,0x10,0x7a,0x49,1,0x65,0x24,0x6c,0x3d,0x19,0x62,0x72,
-0x65,0x77,0x6c,0x65,0x74,0x74,0x65,0x72,0x3d,0x61,0x86,0x63,0x92,0x64,0x94,0x65,
-2,0x62,0x44,0x6d,0x5e,0x78,0x2e,0x13,0x74,0x65,0x6e,0x64,0x32,0x15,0x6e,0x75,
-0x6d,0x6c,0x65,0x74,0x2f,0x42,1,0x61,0x24,0x67,0x45,0x11,0x73,0x65,0x42,0x12,
-0x67,0x61,0x7a,0x45,0x46,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,0x72,0x47,0x15,0x6c,
-0x65,0x74,0x74,0x65,0x72,0x23,0x10,0x72,0x31,1,0x6f,0x24,0x71,0x41,0x18,0x75,
-0x62,0x6c,0x65,0x71,0x75,0x6f,0x74,0x65,0x41,2,0x63,0x32,0x6e,0x3c,0x6f,0x22,
-0x12,0x70,0x65,0x6e,0x23,0x24,0x13,0x6c,0x6f,0x73,0x65,0x25,0x20,0x12,0x6f,0x6e,
-0x65,0x21,0xd,0x6e,0xc1,0x86,0x73,0xa8,0x73,0x4c,0x74,0xa2,0x76,0x75,0xa2,0x83,
-0x7a,0xd8,0x70,0,2,0x6c,0xd9,0x20,0,0x70,0xd9,0x40,0,0x73,0xc3,0,
-0xfe,0xf,0,0,0,7,0x6f,0x3c,0x6f,0xff,8,0,0,0,0x70,0x3a,
-0x75,0x6e,0x79,0x13,0x6d,0x62,0x6f,0x6c,0xff,0xf,0,0,0,0x11,0x61,0x63,
-1,0x65,0x34,0x69,0x15,0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa5,0,0x18,0x73,0x65,
-0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0xc3,0,0x16,0x72,0x72,0x6f,0x67,0x61,0x74,
-0x65,0xe1,0,0,0x63,0xff,2,0,0,0,0x65,0x38,0x6b,0xff,4,0,
-0,0,0x6d,0xff,1,0,0,0,0x16,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,
-0xd9,0x70,0,0x1d,0x69,0x74,0x6c,0x65,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,
-0x65,0x72,0x31,1,0x6e,0x40,0x70,0x1c,0x70,0x65,0x72,0x63,0x61,0x73,0x65,0x6c,
-0x65,0x74,0x74,0x65,0x72,0x25,0x17,0x61,0x73,0x73,0x69,0x67,0x6e,0x65,0x64,0x23,
-0x6e,0xa2,0x69,0x6f,0xa2,0x89,0x70,0xfe,0x30,0xf8,0,0,9,0x69,0x33,0x69,
-0xff,0x10,0,0,0,0x6f,0xfd,0x80,0,0,0x72,0x54,0x73,0xf9,0,0,
-0x75,0x12,0x6e,0x63,0x74,0xfe,0x30,0xf8,0,0,0x15,0x75,0x61,0x74,0x69,0x6f,
-0x6e,0xff,0x30,0xf8,0,0,0x17,0x69,0x76,0x61,0x74,0x65,0x75,0x73,0x65,0xdd,
-0,0,0x61,0x48,0x63,0xfd,0x40,0,0,0x64,0xe9,0,0,0x65,0xfd,0x20,
-0,0,0x66,0xff,0x20,0,0,0,0x1f,0x72,0x61,0x67,0x72,0x61,0x70,0x68,
-0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0xd9,0x40,0,0xbe,0,3,0x64,
-0xa7,0,0x6c,0xab,0,0x6f,0x30,0x75,0x13,0x6d,0x62,0x65,0x72,0xbf,0,0xb2,
-0,0x1b,0x6e,0x73,0x70,0x61,0x63,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa1,1,
-0x70,0x92,0x74,0x12,0x68,0x65,0x72,0xe6,0x80,1,3,0x6c,0x40,0x6e,0x4a,0x70,
-0x56,0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0xff,8,0,0,0,0x14,0x65,0x74,
-0x74,0x65,0x72,0x61,0x14,0x75,0x6d,0x62,0x65,0x72,0xb3,0,0x19,0x75,0x6e,0x63,
-0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xfd,0x80,0,0,0x1c,0x65,0x6e,0x70,0x75,
-0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xf9,0,0,0x66,0xc0,0xc4,0x66,
-0xa2,0x47,0x69,0xa2,0x64,0x6c,0xa2,0x79,0x6d,0xa4,0xc0,4,0x61,0x6c,0x63,0xa5,
-0,0x65,0xa3,0x80,0x6e,0xa1,0x6f,0x15,0x64,0x69,0x66,0x69,0x65,0x72,1,0x6c,
-0x38,0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0xff,4,0,0,0,0x14,0x65,0x74,
-0x74,0x65,0x72,0x41,1,0x72,0x3c,0x74,0x16,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,
-0xff,1,0,0,0,0x10,0x6b,0xa5,0xc0,1,0x69,0x32,0x6f,0x13,0x72,0x6d,
-0x61,0x74,0xdb,0,0,0x1d,0x6e,0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,
-0x74,0x69,0x6f,0x6e,0xff,0x20,0,0,0,0x10,0x6e,0x1f,0x69,0x74,0x69,0x61,
-0x6c,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xff,0x10,0,0,
-0,0x9c,7,0x6d,0x18,0x6d,0x41,0x6f,0x28,0x74,0x31,0x75,0x25,0x60,0x1c,0x77,
-0x65,0x72,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x29,0x63,0x3d,0x65,
-0x28,0x69,0x42,0x6c,0x29,0x13,0x74,0x74,0x65,0x72,0x9c,0x15,0x6e,0x75,0x6d,0x62,
-0x65,0x72,0xab,0,0x1a,0x6e,0x65,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,
-0xd9,0x20,0,0x63,0x46,0x64,0xa2,0x96,0x65,0x1b,0x6e,0x63,0x6c,0x6f,0x73,0x69,
-0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa3,0x80,0xe6,0x80,1,7,0x6e,0x57,0x6e,0x52,
-0x6f,0x5e,0x73,0xe1,0,0,0x75,0x1b,0x72,0x72,0x65,0x6e,0x63,0x79,0x73,0x79,
-0x6d,0x62,0x6f,0x6c,0xff,2,0,0,0,0x22,0x12,0x74,0x72,0x6c,0xd9,0x80,
-0,0xdc,0,0,1,0x6d,0x62,0x6e,1,0x6e,0x30,0x74,0x12,0x72,0x6f,0x6c,
-0xd9,0x80,0,0x1f,0x65,0x63,0x74,0x6f,0x72,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,
-0x74,0x69,0x6f,0x6e,0xfd,0x40,0,0,0x19,0x62,0x69,0x6e,0x69,0x6e,0x67,0x6d,
-0x61,0x72,0x6b,0xa5,0xc0,0x61,0x58,0x63,0xd9,0x80,0,0x66,0xdb,0,0,0x6c,
-0x1d,0x6f,0x73,0x65,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xfd,
-0x20,0,0,0x18,0x73,0x65,0x64,0x6c,0x65,0x74,0x74,0x65,0x72,0x3d,2,0x61,
-0x32,0x65,0x50,0x69,0x12,0x67,0x69,0x74,0xa7,0,0x1c,0x73,0x68,0x70,0x75,0x6e,
-0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xe9,0,0,0x1a,0x63,0x69,0x6d,0x61,
-0x6c,0x6e,0x75,0x6d,0x62,0x65,0x72,0xa7,0
+0xa3,0xd7,0x15,0x75,0x72,0x73,0x69,0x76,0x65,0xa3,0xd6,0x17,0x65,0x66,0x61,0x69,
+0x64,0x72,0x69,0x6e,0xa5,0x21,0x17,0x74,0x65,0x69,0x6d,0x61,0x79,0x65,0x6b,0xa2,
+0xb8,0x12,0x65,0x78,0x74,0xa2,0xd5,0x16,0x65,0x6e,0x73,0x69,0x6f,0x6e,0x73,0xa3,
+0xd5,0x18,0x64,0x65,0x6b,0x69,0x6b,0x61,0x6b,0x75,0x69,0xa3,0xeb,5,0x6b,0x23,
+0x6b,0x4c,0x6f,0x50,0x75,1,0x6d,0x2c,0x73,0x11,0x68,0x75,0xa5,0x15,0x17,0x62,
+0x65,0x72,0x66,0x6f,0x72,0x6d,0x73,0x7b,0x10,0x6f,0xa3,0x92,0x14,0x62,0x6c,0x6f,
+0x63,0x6b,0x21,0x61,0x44,0x62,0x21,0x65,0x10,0x77,1,0x61,0xa5,0xe,0x74,0x14,
+0x61,0x69,0x6c,0x75,0x65,0xa3,0x8b,0x16,0x62,0x61,0x74,0x61,0x65,0x61,0x6e,0xa3,
+0xef,0x67,0xc4,0xe,0x6a,0xc1,0x95,0x6a,0xa2,0xc5,0x6b,0xa2,0xde,0x6c,4,0x61,
+0x54,0x65,0xa2,0x61,0x69,0xa2,0x78,0x6f,0xa2,0xa7,0x79,1,0x63,0x2e,0x64,0x12,
+0x69,0x61,0x6e,0xa3,0xa9,0x12,0x69,0x61,0x6e,0xa3,0xa7,1,0x6f,0x55,0x74,0x11,
+0x69,0x6e,1,0x31,0x82,0x65,0x11,0x78,0x74,4,0x61,0x5c,0x62,0x29,0x63,0xa3,
+0x94,0x64,0xa3,0x95,0x65,0xa2,0xe7,0x13,0x6e,0x64,0x65,0x64,4,0x61,0x36,0x62,
+0x29,0x63,0xa3,0x94,0x64,0xa3,0x95,0x65,0xa3,0xe7,0x26,0x18,0x64,0x64,0x69,0x74,
+0x69,0x6f,0x6e,0x61,0x6c,0x6d,0x24,0x12,0x73,0x75,0x70,0x24,0x16,0x70,0x6c,0x65,
+0x6d,0x65,0x6e,0x74,0x25,1,0x70,0x42,0x74,0x1d,0x74,0x65,0x72,0x6c,0x69,0x6b,
+0x65,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x79,0x12,0x63,0x68,0x61,0xa3,0x9c,2,
+0x6d,0x2e,0x6e,0x34,0x73,0x10,0x75,0xa3,0xb0,0x11,0x62,0x75,0xa3,0x6f,0x12,0x65,
+0x61,0x72,1,0x61,0xa3,0xe8,0x62,1,0x69,0x38,0x73,0x17,0x79,0x6c,0x6c,0x61,
+0x62,0x61,0x72,0x79,0xa3,0x75,0x17,0x64,0x65,0x6f,0x67,0x72,0x61,0x6d,0x73,0xa3,
+0x76,0x1a,0x77,0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,0xa3,0x4d,0x10,
+0x61,1,0x6d,0x32,0x76,0x14,0x61,0x6e,0x65,0x73,0x65,0xa3,0xb5,0x10,0x6f,0x5c,
+0x12,0x65,0x78,0x74,1,0x61,0xa3,0xb4,0x62,0xa3,0xb9,1,0x61,0x80,0x68,3,
+0x61,0x3c,0x6d,0x4c,0x6f,0x64,0x75,0x15,0x64,0x61,0x77,0x61,0x64,0x69,0xa3,0xe6,
+0x16,0x72,0x6f,0x73,0x68,0x74,0x68,0x69,0xa3,0x89,0x11,0x65,0x72,0x68,0x16,0x73,
+0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x71,0x12,0x6a,0x6b,0x69,0xa3,0xe5,3,0x69,
+0x3a,0x6e,0x42,0x74,0xa2,0x51,0x79,0x13,0x61,0x68,0x6c,0x69,0xa3,0xa2,0x12,0x74,
+0x68,0x69,0xa3,0xc1,3,0x61,0x34,0x62,0x76,0x67,0x7c,0x6e,0x12,0x61,0x64,0x61,
+0x4d,1,0x65,0x40,0x73,0x11,0x75,0x70,0xa2,0xcb,0x16,0x70,0x6c,0x65,0x6d,0x65,
+0x6e,0x74,0xa3,0xcb,0x11,0x78,0x74,1,0x61,0xa5,0x13,0x65,0x14,0x6e,0x64,0x65,
+0x64,0x61,0xa5,0x13,0x11,0x75,0x6e,0xa3,0x42,0x11,0x78,0x69,0x96,0x17,0x72,0x61,
+0x64,0x69,0x63,0x61,0x6c,0x73,0x97,0x14,0x61,0x6b,0x61,0x6e,0x61,0x9e,1,0x65,
+0x4c,0x70,0x10,0x68,0x1f,0x6f,0x6e,0x65,0x74,0x69,0x63,0x65,0x78,0x74,0x65,0x6e,
+0x73,0x69,0x6f,0x6e,0x73,0xa3,0x6b,0x11,0x78,0x74,0xa3,0x6b,0x67,0xa2,0xb5,0x68,
+0xa4,0x84,0x69,3,0x64,0x4c,0x6d,0xa2,0x55,0x6e,0xa2,0x62,0x70,0x13,0x61,0x65,
+0x78,0x74,0x2a,0x16,0x65,0x6e,0x73,0x69,0x6f,0x6e,0x73,0x2b,1,0x63,0x99,0x65,
+0x17,0x6f,0x67,0x72,0x61,0x70,0x68,0x69,0x63,1,0x64,0x56,0x73,0x15,0x79,0x6d,
+0x62,0x6f,0x6c,0x73,0xa4,0xb,0x1d,0x61,0x6e,0x64,0x70,0x75,0x6e,0x63,0x74,0x75,
+0x61,0x74,0x69,0x6f,0x6e,0xa5,0xb,0x13,0x65,0x73,0x63,0x72,0x1f,0x69,0x70,0x74,
+0x69,0x6f,0x6e,0x63,0x68,0x61,0x72,0x61,0x63,0x74,0x65,0x72,0x73,0x99,0x1c,0x70,
+0x65,0x72,0x69,0x61,0x6c,0x61,0x72,0x61,0x6d,0x61,0x69,0x63,0xa3,0xba,1,0x64,
+0x62,0x73,0x1b,0x63,0x72,0x69,0x70,0x74,0x69,0x6f,0x6e,0x61,0x6c,0x70,0x61,1,
+0x68,0x32,0x72,0x14,0x74,0x68,0x69,0x61,0x6e,0xa3,0xbd,0x13,0x6c,0x61,0x76,0x69,
+0xa3,0xbe,0x11,0x69,0x63,1,0x6e,0x3e,0x73,0x1a,0x69,0x79,0x61,0x71,0x6e,0x75,
+0x6d,0x62,0x65,0x72,0x73,0xa5,0x1e,0x19,0x75,0x6d,0x62,0x65,0x72,0x66,0x6f,0x72,
+0x6d,0x73,0xa3,0xb2,4,0x65,0x74,0x6c,0xa2,0x82,0x6f,0xa2,0x9a,0x72,0xa2,0x9e,
+0x75,2,0x6a,0x34,0x6e,0x3e,0x72,0x14,0x6d,0x75,0x6b,0x68,0x69,0x43,0x14,0x61,
+0x72,0x61,0x74,0x69,0x45,0x18,0x6a,0x61,0x6c,0x61,0x67,0x6f,0x6e,0x64,0x69,0xa5,
+0x1c,1,0x6e,0xa2,0x46,0x6f,1,0x6d,0x6e,0x72,0x13,0x67,0x69,0x61,0x6e,0x5a,
+1,0x65,0x40,0x73,0x11,0x75,0x70,0xa2,0x87,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,
+0x74,0xa3,0x87,0x11,0x78,0x74,0xa4,0x1b,0x14,0x65,0x6e,0x64,0x65,0x64,0xa5,0x1b,
+0x1a,0x65,0x74,0x72,0x69,0x63,0x73,0x68,0x61,0x70,0x65,0x73,0x8c,0x12,0x65,0x78,
+0x74,0xa2,0xe3,0x14,0x65,0x6e,0x64,0x65,0x64,0xa3,0xe3,0x1e,0x65,0x72,0x61,0x6c,
+0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x71,0x17,0x61,0x67,0x6f,
+0x6c,0x69,0x74,0x69,0x63,0xa2,0x88,0x12,0x73,0x75,0x70,0xa4,0xa,0x16,0x70,0x6c,
+0x65,0x6d,0x65,0x6e,0x74,0xa5,0xa,0x13,0x74,0x68,0x69,0x63,0xa3,0x59,1,0x61,
+0x5c,0x65,0x11,0x65,0x6b,0x30,1,0x61,0x38,0x65,0x11,0x78,0x74,0x6e,0x14,0x65,
+0x6e,0x64,0x65,0x64,0x6f,0x17,0x6e,0x64,0x63,0x6f,0x70,0x74,0x69,0x63,0x31,0x13,
+0x6e,0x74,0x68,0x61,0xa3,0xe4,2,0x61,0xa2,0x48,0x65,0xa2,0xdf,0x69,1,0x67,
+0x30,0x72,0x14,0x61,0x67,0x61,0x6e,0x61,0x9d,0x10,0x68,1,0x70,0x3a,0x73,0x18,
+0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,0xa3,0x4b,1,0x72,0x3c,0x75,0x19,
+0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,0xa3,0x4c,0x11,0x69,0x76,0x1f,
+0x61,0x74,0x65,0x75,0x73,0x65,0x73,0x75,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x73,
+0xa3,0x4c,2,0x6c,0x32,0x6e,0x9a,0x74,0x12,0x72,0x61,0x6e,0xa5,2,0x10,0x66,
+2,0x61,0x58,0x6d,0x70,0x77,0x14,0x69,0x64,0x74,0x68,0x61,0x1f,0x6e,0x64,0x66,
+0x75,0x6c,0x6c,0x77,0x69,0x64,0x74,0x68,0x66,0x6f,0x72,0x6d,0x73,0xa3,0x57,0x1a,
+0x6e,0x64,0x66,0x75,0x6c,0x6c,0x66,0x6f,0x72,0x6d,0x73,0xa3,0x57,0x13,0x61,0x72,
+0x6b,0x73,0xa3,0x52,2,0x67,0x34,0x69,0xa2,0x45,0x75,0x12,0x6e,0x6f,0x6f,0xa3,
+0x63,0x11,0x75,0x6c,0xa2,0x4a,2,0x63,0x3c,0x6a,0x5e,0x73,0x17,0x79,0x6c,0x6c,
+0x61,0x62,0x6c,0x65,0x73,0xa3,0x4a,0x1f,0x6f,0x6d,0x70,0x61,0x74,0x69,0x62,0x69,
+0x6c,0x69,0x74,0x79,0x6a,0x61,0x6d,0x6f,0xa3,0x41,0x12,0x61,0x6d,0x6f,0x5c,0x17,
+0x65,0x78,0x74,0x65,0x6e,0x64,0x65,0x64,1,0x61,0xa3,0xb4,0x62,0xa3,0xb9,0x19,
+0x66,0x69,0x72,0x6f,0x68,0x69,0x6e,0x67,0x79,0x61,0xa5,0x1d,0x13,0x62,0x72,0x65,
+0x77,0x37,0x61,0xa2,0xe9,0x62,0xa6,0x29,0x63,0xa6,0xfe,0x64,0xac,0x8a,0x65,5,
+0x6d,0xa2,0x6d,0x86,0x6e,0x96,0x74,0x15,0x68,0x69,0x6f,0x70,0x69,0x63,0x5e,1,
+0x65,0x40,0x73,0x11,0x75,0x70,0xa2,0x86,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,
+0xa3,0x86,0x11,0x78,0x74,0xa2,0x85,1,0x61,0xa3,0xc8,0x65,0x13,0x6e,0x64,0x65,
+0x64,0xa2,0x85,0x10,0x61,0xa3,0xc8,0x16,0x6f,0x74,0x69,0x63,0x6f,0x6e,0x73,0xa3,
+0xce,0x15,0x63,0x6c,0x6f,0x73,0x65,0x64,2,0x61,0x5a,0x63,0x9e,0x69,0x1c,0x64,
+0x65,0x6f,0x67,0x72,0x61,0x70,0x68,0x69,0x63,0x73,0x75,0x70,0xa2,0xc4,0x16,0x70,
+0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xc4,0x16,0x6c,0x70,0x68,0x61,0x6e,0x75,0x6d,
+0x86,1,0x65,0x2c,0x73,0x11,0x75,0x70,0xa3,0xc3,0x13,0x72,0x69,0x63,0x73,0x86,
+0x18,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xc3,0x11,0x6a,0x6b,0xa2,
+0x44,0x1f,0x6c,0x65,0x74,0x74,0x65,0x72,0x73,0x61,0x6e,0x64,0x6d,0x6f,0x6e,0x74,
+0x68,0x73,0xa3,0x44,0x61,0x36,0x67,0x62,0x6c,0x14,0x62,0x61,0x73,0x61,0x6e,0xa3,
+0xe2,0x13,0x72,0x6c,0x79,0x64,0x1f,0x79,0x6e,0x61,0x73,0x74,0x69,0x63,0x63,0x75,
+0x6e,0x65,0x69,0x66,0x6f,0x72,0x6d,0xa5,1,0x10,0x79,0x1f,0x70,0x74,0x69,0x61,
+0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,0x68,0x73,0xa3,0xc2,7,0x6e,
+0xc0,0xe5,0x6e,0x3e,0x72,0xa2,0x5d,0x73,0xa2,0xd8,0x76,0x14,0x65,0x73,0x74,0x61,
+0x6e,0xa3,0xbc,1,0x61,0x92,0x63,0x13,0x69,0x65,0x6e,0x74,1,0x67,0x34,0x73,
+0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xa5,0x13,0x72,0x65,0x65,0x6b,1,0x6d,
+0x34,0x6e,0x15,0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0x7f,0x13,0x75,0x73,0x69,0x63,
+0xa2,0x7e,0x19,0x61,0x6c,0x6e,0x6f,0x74,0x61,0x74,0x69,0x6f,0x6e,0xa3,0x7e,0x10,
+0x74,0x1f,0x6f,0x6c,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,
+0x68,0x73,0xa3,0xfe,2,0x61,0x32,0x6d,0xa2,0x71,0x72,0x12,0x6f,0x77,0x73,0x7d,
+0x12,0x62,0x69,0x63,0x38,3,0x65,0x4a,0x6d,0x66,0x70,0xa2,0x43,0x73,0x11,0x75,
+0x70,0xa2,0x80,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x80,0x11,0x78,0x74,
+1,0x61,0xa3,0xd2,0x65,0x14,0x6e,0x64,0x65,0x64,0x61,0xa3,0xd2,0x12,0x61,0x74,
+0x68,0xa2,0xd3,0x18,0x65,0x6d,0x61,0x74,0x69,0x63,0x61,0x6c,0x61,0x1f,0x6c,0x70,
+0x68,0x61,0x62,0x65,0x74,0x69,0x63,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xd3,
+1,0x66,0x42,0x72,0x1e,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,0x6e,0x66,
+0x6f,0x72,0x6d,0x73,1,0x61,0xa3,0x51,0x62,0xa3,0x55,0x14,0x65,0x6e,0x69,0x61,
+0x6e,0x35,0x12,0x63,0x69,0x69,0x23,0x64,0x9e,0x65,0xa2,0x42,0x68,0xa2,0x4d,0x6c,
+1,0x63,0x62,0x70,0x17,0x68,0x61,0x62,0x65,0x74,0x69,0x63,0x70,1,0x66,0xa3,
+0x50,0x72,0x1e,0x65,0x73,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,0x6e,0x66,0x6f,0x72,
+0x6d,0x73,0xa3,0x50,0x16,0x68,0x65,0x6d,0x69,0x63,0x61,0x6c,0xa2,0xd0,0x16,0x73,
+0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0xd0,0x12,0x6c,0x61,0x6d,0xa5,7,0x1a,0x67,
+0x65,0x61,0x6e,0x6e,0x75,0x6d,0x62,0x65,0x72,0x73,0xa3,0x77,0x11,0x6f,0x6d,0xa3,
+0xfd,7,0x6f,0x71,0x6f,0x64,0x72,0xa2,0x41,0x75,0xa2,0x58,0x79,0x1b,0x7a,0x61,
+0x6e,0x74,0x69,0x6e,0x65,0x6d,0x75,0x73,0x69,0x63,0xa2,0x5b,0x18,0x61,0x6c,0x73,
+0x79,0x6d,0x62,0x6f,0x6c,0x73,0xa3,0x5b,1,0x70,0x34,0x78,0x16,0x64,0x72,0x61,
+0x77,0x69,0x6e,0x67,0x89,0x14,0x6f,0x6d,0x6f,0x66,0x6f,0xa0,0x12,0x65,0x78,0x74,
+0xa2,0x43,0x14,0x65,0x6e,0x64,0x65,0x64,0xa3,0x43,0x10,0x61,1,0x68,0x40,0x69,
+0x12,0x6c,0x6c,0x65,0x92,0x17,0x70,0x61,0x74,0x74,0x65,0x72,0x6e,0x73,0x93,0x11,
+0x6d,0x69,0xa3,0xc9,1,0x67,0x2c,0x68,0x11,0x69,0x64,0xa3,0x64,0x14,0x69,0x6e,
+0x65,0x73,0x65,0xa3,0x81,0x61,0x48,0x65,0xa2,0x4e,0x68,0xa2,0x52,0x6c,0x1a,0x6f,
+0x63,0x6b,0x65,0x6c,0x65,0x6d,0x65,0x6e,0x74,0x73,0x8b,3,0x6c,0x34,0x6d,0x40,
+0x73,0x66,0x74,0x11,0x61,0x6b,0xa3,0xc7,0x14,0x69,0x6e,0x65,0x73,0x65,0xa3,0x93,
+0x11,0x75,0x6d,0xa2,0xb1,0x12,0x73,0x75,0x70,0xa2,0xca,0x16,0x70,0x6c,0x65,0x6d,
+0x65,0x6e,0x74,0xa3,0xca,1,0x69,0x30,0x73,0x13,0x61,0x76,0x61,0x68,0xa3,0xdd,
+0x15,0x63,0x6c,0x61,0x74,0x69,0x6e,0x23,0x14,0x6e,0x67,0x61,0x6c,0x69,0x41,0x16,
+0x61,0x69,0x6b,0x73,0x75,0x6b,0x69,0xa5,8,5,0x6f,0xc1,0x4c,0x6f,0xa2,0x55,
+0x75,0xa4,0x10,0x79,1,0x70,0x9c,0x72,0x14,0x69,0x6c,0x6c,0x69,0x63,0x32,1,
+0x65,0x4c,0x73,0x11,0x75,0x70,0xa2,0x61,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,
+0xa2,0x61,0x12,0x61,0x72,0x79,0xa3,0x61,0x11,0x78,0x74,3,0x61,0xa3,0x9e,0x62,
+0xa3,0xa0,0x63,0xa5,9,0x65,0x13,0x6e,0x64,0x65,0x64,2,0x61,0xa3,0x9e,0x62,
+0xa3,0xa0,0x63,0xa5,9,0x1c,0x72,0x69,0x6f,0x74,0x73,0x79,0x6c,0x6c,0x61,0x62,
+0x61,0x72,0x79,0xa3,0x7b,3,0x6d,0x5a,0x6e,0xa2,0x95,0x70,0xa2,0xa0,0x75,0x17,
+0x6e,0x74,0x69,0x6e,0x67,0x72,0x6f,0x64,0xa2,0x9a,0x17,0x6e,0x75,0x6d,0x65,0x72,
+0x61,0x6c,0x73,0xa3,0x9a,2,0x62,0x3a,0x6d,0xa2,0x5f,0x70,0x15,0x61,0x74,0x6a,
+0x61,0x6d,0x6f,0xa3,0x41,0x14,0x69,0x6e,0x69,0x6e,0x67,2,0x64,0x46,0x68,0x9e,
+0x6d,0x1d,0x61,0x72,0x6b,0x73,0x66,0x6f,0x72,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,
+0x77,0x1e,0x69,0x61,0x63,0x72,0x69,0x74,0x69,0x63,0x61,0x6c,0x6d,0x61,0x72,0x6b,
+0x73,0x2e,2,0x65,0x40,0x66,0xa6,0x2a,0x73,0x18,0x75,0x70,0x70,0x6c,0x65,0x6d,
+0x65,0x6e,0x74,0xa3,0x83,0x16,0x78,0x74,0x65,0x6e,0x64,0x65,0x64,0xa3,0xe0,0x17,
+0x61,0x6c,0x66,0x6d,0x61,0x72,0x6b,0x73,0xa3,0x52,0x11,0x6f,0x6e,0x1f,0x69,0x6e,
+0x64,0x69,0x63,0x6e,0x75,0x6d,0x62,0x65,0x72,0x66,0x6f,0x72,0x6d,0x73,0xa3,0xb2,
+0x1b,0x74,0x72,0x6f,0x6c,0x70,0x69,0x63,0x74,0x75,0x72,0x65,0x73,0x83,0x12,0x74,
+0x69,0x63,0xa2,0x84,0x1b,0x65,0x70,0x61,0x63,0x74,0x6e,0x75,0x6d,0x62,0x65,0x72,
+0x73,0xa3,0xdf,1,0x6e,0x3e,0x72,0x1b,0x72,0x65,0x6e,0x63,0x79,0x73,0x79,0x6d,
+0x62,0x6f,0x6c,0x73,0x75,0x15,0x65,0x69,0x66,0x6f,0x72,0x6d,0xa2,0x98,0x16,0x6e,
+0x75,0x6d,0x62,0x65,0x72,0x73,0xa2,0x99,0x1d,0x61,0x6e,0x64,0x70,0x75,0x6e,0x63,
+0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xa3,0x99,0x61,0xa2,0xdb,0x68,0xa4,5,0x6a,
+0x10,0x6b,0xa2,0x47,4,0x63,0x86,0x65,0xa2,0x7d,0x72,0xa2,0x92,0x73,0xa2,0xa4,
+0x75,0x1f,0x6e,0x69,0x66,0x69,0x65,0x64,0x69,0x64,0x65,0x6f,0x67,0x72,0x61,0x70,
+0x68,0x73,0xa2,0x47,0x18,0x65,0x78,0x74,0x65,0x6e,0x73,0x69,0x6f,0x6e,5,0x64,
+0x65,0x64,0xa3,0xd1,0x65,0xa5,0,0x66,0xa5,0x12,0x14,0x6f,0x6d,0x70,0x61,0x74,
+0xa2,0x45,1,0x66,0x96,0x69,1,0x62,0x44,0x64,0x17,0x65,0x6f,0x67,0x72,0x61,
+0x70,0x68,0x73,0xa2,0x4f,0x12,0x73,0x75,0x70,0xa3,0x5f,0x14,0x69,0x6c,0x69,0x74,
+0x79,0xa2,0x45,1,0x66,0x54,0x69,0x18,0x64,0x65,0x6f,0x67,0x72,0x61,0x70,0x68,
+0x73,0xa2,0x4f,0x19,0x73,0x75,0x70,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0x5f,
+0x13,0x6f,0x72,0x6d,0x73,0xa3,0x53,0x11,0x78,0x74,5,0x64,9,0x64,0xa3,0xd1,
+0x65,0xa5,0,0x66,0xa5,0x12,0x61,0xa3,0x46,0x62,0xa3,0x5e,0x63,0xa3,0xc5,0x19,
+0x61,0x64,0x69,0x63,0x61,0x6c,0x73,0x73,0x75,0x70,0x94,0x16,0x70,0x6c,0x65,0x6d,
+0x65,0x6e,0x74,0x95,1,0x74,0x50,0x79,0x14,0x6d,0x62,0x6f,0x6c,0x73,0x9a,0x1d,
+0x61,0x6e,0x64,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x9b,0x14,
+0x72,0x6f,0x6b,0x65,0x73,0xa3,0x82,2,0x6e,0x48,0x72,0x64,0x75,0x1d,0x63,0x61,
+0x73,0x69,0x61,0x6e,0x61,0x6c,0x62,0x61,0x6e,0x69,0x61,0x6e,0xa3,0xde,0x1d,0x61,
+0x64,0x69,0x61,0x6e,0x73,0x79,0x6c,0x6c,0x61,0x62,0x69,0x63,0x73,0x63,0x12,0x69,
+0x61,0x6e,0xa3,0xa8,1,0x61,0x6c,0x65,1,0x72,0x38,0x73,0x17,0x73,0x73,0x79,
+0x6d,0x62,0x6f,0x6c,0x73,0xa5,0x19,0x13,0x6f,0x6b,0x65,0x65,0x60,0x12,0x73,0x75,
+0x70,0xa2,0xff,0x16,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0xa3,0xff,1,0x6b,0x26,
+0x6d,0xa3,0xa4,0x11,0x6d,0x61,0xa3,0xd4,3,0x65,0x3e,0x69,0x7e,0x6f,0xa2,0x5d,
+0x75,0x15,0x70,0x6c,0x6f,0x79,0x61,0x6e,0xa3,0xe1,1,0x73,0x50,0x76,0x16,0x61,
+0x6e,0x61,0x67,0x61,0x72,0x69,0x3e,0x12,0x65,0x78,0x74,0xa2,0xb3,0x14,0x65,0x6e,
+0x64,0x65,0x64,0xa3,0xb3,0x13,0x65,0x72,0x65,0x74,0xa3,0x5a,1,0x61,0x30,0x6e,
+0x14,0x67,0x62,0x61,0x74,0x73,0x91,0x18,0x63,0x72,0x69,0x74,0x69,0x63,0x61,0x6c,
+0x73,0x2e,2,0x65,0x30,0x66,0x36,0x73,0x11,0x75,0x70,0xa3,0x83,0x11,0x78,0x74,
+0xa3,0xe0,0x18,0x6f,0x72,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x77,1,0x67,0x3e,
+0x6d,0x12,0x69,0x6e,0x6f,0xa2,0xab,0x14,0x74,0x69,0x6c,0x65,0x73,0xa3,0xab,0x11,
+0x72,0x61,0xa5,0x1a,8,0x6d,0x5f,0x6d,0x3a,0x6e,0x48,0x73,0x7a,0x76,0xa2,0x4b,
+0x77,0x12,0x69,0x64,0x65,0x43,0x11,0x65,0x64,0x32,0x12,0x69,0x61,0x6c,0x33,2,
+0x61,0x40,0x62,0x37,0x6f,1,0x62,0x28,0x6e,0x10,0x65,0x21,0x13,0x72,0x65,0x61,
+0x6b,0x37,0x10,0x72,0x34,0x12,0x72,0x6f,0x77,0x35,2,0x6d,0x38,0x71,0x46,0x75,
+1,0x62,0x3d,0x70,0x3e,0x11,0x65,0x72,0x3f,1,0x61,0x24,0x6c,0x39,0x11,0x6c,
+0x6c,0x39,1,0x72,0x3b,0x75,0x12,0x61,0x72,0x65,0x3b,0x12,0x65,0x72,0x74,0x40,
+0x13,0x69,0x63,0x61,0x6c,0x41,0x63,0x58,0x65,0x92,0x66,0x96,0x69,1,0x6e,0x36,
+0x73,0x10,0x6f,0x30,0x14,0x6c,0x61,0x74,0x65,0x64,0x31,0x11,0x69,0x74,0x2e,0x12,
+0x69,0x61,0x6c,0x2f,2,0x61,0x36,0x69,0x48,0x6f,0x10,0x6d,0x24,0x12,0x70,0x61,
+0x74,0x25,0x10,0x6e,0x22,0x15,0x6f,0x6e,0x69,0x63,0x61,0x6c,0x23,0x13,0x72,0x63,
+0x6c,0x65,0x27,0x11,0x6e,0x63,0x27,2,0x69,0x3a,0x6f,0x44,0x72,0x10,0x61,0x2c,
+0x14,0x63,0x74,0x69,0x6f,0x6e,0x2d,0x10,0x6e,0x28,0x11,0x61,0x6c,0x29,0x11,0x6e,
+0x74,0x2b,4,0x61,0x3a,0x66,0x4c,0x68,0x5e,0x6e,0x70,0x77,0x2a,0x12,0x69,0x64,
+0x65,0x2b,0x22,0x17,0x6d,0x62,0x69,0x67,0x75,0x6f,0x75,0x73,0x23,0x26,0x17,0x75,
+0x6c,0x6c,0x77,0x69,0x64,0x74,0x68,0x27,0x24,0x17,0x61,0x6c,0x66,0x77,0x69,0x64,
+0x74,0x68,0x25,0x20,1,0x61,0x30,0x65,0x14,0x75,0x74,0x72,0x61,0x6c,0x21,0x28,
+0x13,0x72,0x72,0x6f,0x77,0x29,0xd,0x6e,0xc0,0xfb,0x73,0x6d,0x73,0x3a,0x74,0x98,
+0x75,0xa2,0x49,0x7a,2,0x6c,0x3b,0x70,0x3d,0x73,0x39,5,0x6f,0x28,0x6f,0x57,
+0x70,0x34,0x75,0x16,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x45,0x11,0x61,0x63,1,
+0x65,0x32,0x69,0x15,0x6e,0x67,0x6d,0x61,0x72,0x6b,0x31,0x18,0x73,0x65,0x70,0x61,
+0x72,0x61,0x74,0x6f,0x72,0x39,0x63,0x53,0x6b,0x55,0x6d,0x51,0x1d,0x69,0x74,0x6c,
+0x65,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x27,1,0x6e,0x40,0x70,
+0x1c,0x70,0x65,0x72,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x23,0x17,
+0x61,0x73,0x73,0x69,0x67,0x6e,0x65,0x64,0x21,0x6e,0x8a,0x6f,0xa2,0x47,0x70,8,
+0x66,0x14,0x66,0x5b,0x69,0x59,0x6f,0x4f,0x72,0x24,0x73,0x49,0x17,0x69,0x76,0x61,
+0x74,0x65,0x75,0x73,0x65,0x43,0x61,0x2c,0x63,0x4d,0x64,0x47,0x65,0x4b,0x1f,0x72,
+0x61,0x67,0x72,0x61,0x70,0x68,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0x3d,
+2,0x64,0x33,0x6c,0x35,0x6f,0x36,0x1b,0x6e,0x73,0x70,0x61,0x63,0x69,0x6e,0x67,
+0x6d,0x61,0x72,0x6b,0x2d,1,0x70,0x7c,0x74,0x12,0x68,0x65,0x72,3,0x6c,0x38,
+0x6e,0x42,0x70,0x4c,0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0x57,0x14,0x65,0x74,0x74,
+0x65,0x72,0x2b,0x14,0x75,0x6d,0x62,0x65,0x72,0x37,0x19,0x75,0x6e,0x63,0x74,0x75,
+0x61,0x74,0x69,0x6f,0x6e,0x4f,0x1c,0x65,0x6e,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,
+0x74,0x69,0x6f,0x6e,0x49,0x66,0x9e,0x66,0x88,0x69,0xa2,0x4b,0x6c,0xa2,0x5c,0x6d,
+4,0x61,0x60,0x63,0x31,0x65,0x2f,0x6e,0x2d,0x6f,0x15,0x64,0x69,0x66,0x69,0x65,
+0x72,1,0x6c,0x30,0x73,0x14,0x79,0x6d,0x62,0x6f,0x6c,0x55,0x14,0x65,0x74,0x74,
+0x65,0x72,0x29,0x17,0x74,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,0x51,1,0x69,0x2e,
+0x6f,0x13,0x72,0x6d,0x61,0x74,0x41,0x1d,0x6e,0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,
+0x75,0x61,0x74,0x69,0x6f,0x6e,0x5b,0x10,0x6e,0x1f,0x69,0x74,0x69,0x61,0x6c,0x70,
+0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x59,6,0x6d,0x18,0x6d,0x29,
+0x6f,0x28,0x74,0x27,0x75,0x23,0x2a,0x1c,0x77,0x65,0x72,0x63,0x61,0x73,0x65,0x6c,
+0x65,0x74,0x74,0x65,0x72,0x25,0x65,0x28,0x69,0x3c,0x6c,0x25,0x19,0x74,0x74,0x65,
+0x72,0x6e,0x75,0x6d,0x62,0x65,0x72,0x35,0x1a,0x6e,0x65,0x73,0x65,0x70,0x61,0x72,
+0x61,0x74,0x6f,0x72,0x3b,0x63,0x44,0x64,0xa2,0x60,0x65,0x1b,0x6e,0x63,0x6c,0x6f,
+0x73,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,0x2f,6,0x6e,0x39,0x6e,0x46,0x6f,0x4e,
+0x73,0x45,0x75,0x1b,0x72,0x72,0x65,0x6e,0x63,0x79,0x73,0x79,0x6d,0x62,0x6f,0x6c,
+0x53,0x20,0x12,0x74,0x72,0x6c,0x3f,0x42,0x10,0x6e,1,0x6e,0x2c,0x74,0x12,0x72,
+0x6f,0x6c,0x3f,0x1f,0x65,0x63,0x74,0x6f,0x72,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,
+0x74,0x69,0x6f,0x6e,0x4d,0x63,0x3f,0x66,0x41,0x6c,0x1d,0x6f,0x73,0x65,0x70,0x75,
+0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x4b,2,0x61,0x30,0x65,0x4a,0x69,
+0x12,0x67,0x69,0x74,0x33,0x1c,0x73,0x68,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,
+0x69,0x6f,0x6e,0x47,0x1a,0x63,0x69,0x6d,0x61,0x6c,0x6e,0x75,0x6d,0x62,0x65,0x72,
+0x33,0,0x12,0x6d,0xc2,0x3f,0x73,0xa1,0x73,0x4e,0x74,0xa2,0x56,0x77,0xa2,0x72,
+0x79,0xa2,0x73,0x7a,1,0x61,0x2c,0x68,0x12,0x61,0x69,0x6e,0x8b,0x11,0x69,0x6e,
+0x85,5,0x74,0x22,0x74,0x38,0x77,0x4c,0x79,0x16,0x72,0x69,0x61,0x63,0x77,0x61,
+0x77,0x6f,0x18,0x72,0x61,0x69,0x67,0x68,0x74,0x77,0x61,0x77,0xa3,0x55,0x15,0x61,
+0x73,0x68,0x6b,0x61,0x66,0x6d,0x61,0x2e,0x65,0x38,0x68,0x11,0x69,0x6e,0x6b,0x10,
+0x64,0x62,0x11,0x68,0x65,0x65,1,0x65,0x2e,0x6d,0x13,0x6b,0x61,0x74,0x68,0x69,
+0x10,0x6e,0x67,1,0x61,0x4e,0x65,1,0x68,0x28,0x74,0x10,0x68,0x77,0x16,0x6d,
+0x61,0x72,0x62,0x75,0x74,0x61,0x74,0x13,0x67,0x6f,0x61,0x6c,0x3d,1,0x68,0x71,
+0x77,0x73,0x11,0x61,0x77,0x79,1,0x65,0x32,0x75,0x11,0x64,0x68,0x80,0x11,0x68,
+0x65,0x83,0x10,0x68,0x7a,1,0x62,0x34,0x77,0x16,0x69,0x74,0x68,0x74,0x61,0x69,
+0x6c,0x7f,0x14,0x61,0x72,0x72,0x65,0x65,0x7d,0x6d,0x6c,0x6e,0xa4,0x6b,0x70,0xa4,
+0x88,0x71,0xa4,0x88,0x72,1,0x65,0x38,0x6f,0x18,0x68,0x69,0x6e,0x67,0x79,0x61,
+0x79,0x65,0x68,0x93,1,0x68,0x5f,0x76,0x16,0x65,0x72,0x73,0x65,0x64,0x70,0x65,
+0x61,2,0x61,0x2e,0x65,0xa4,0x3e,0x69,0x10,0x6d,0x53,1,0x6c,0xa2,0xe7,0x6e,
+0x16,0x69,0x63,0x68,0x61,0x65,0x61,0x6e,0,0x12,0x6e,0x76,0x73,0x51,0x73,0x3e,
+0x74,0x5c,0x77,0xa0,0x79,0xa2,0x42,0x7a,0x13,0x61,0x79,0x69,0x6e,0xa3,0x54,0x10,
+0x61,1,0x64,0x2e,0x6d,0x12,0x65,0x6b,0x68,0xa3,0x4c,0x11,0x68,0x65,0xa3,0x4b,
+3,0x61,0x38,0x65,0x3c,0x68,0x4a,0x77,0x13,0x65,0x6e,0x74,0x79,0xa3,0x51,0x10,
+0x77,0xa3,0x4d,1,0x6e,0xa3,0x4e,0x74,0x10,0x68,0xa3,0x4f,0x14,0x61,0x6d,0x65,
+0x64,0x68,0xa3,0x50,0x11,0x61,0x77,0xa3,0x52,0x12,0x6f,0x64,0x68,0xa3,0x53,0x6e,
+0x3a,0x6f,0x40,0x70,0x46,0x71,0x4a,0x72,0x12,0x65,0x73,0x68,0xa3,0x4a,0x11,0x75,
+0x6e,0xa3,0x46,0x11,0x6e,0x65,0xa3,0x47,0x10,0x65,0xa3,0x48,0x12,0x6f,0x70,0x68,
+0xa3,0x49,0x67,0x33,0x67,0x38,0x68,0x40,0x6b,0x5e,0x6c,0x66,0x6d,0x11,0x65,0x6d,
+0xa3,0x45,0x13,0x69,0x6d,0x65,0x6c,0xa1,1,0x65,0x32,0x75,0x14,0x6e,0x64,0x72,
+0x65,0x64,0xa3,0x42,0x11,0x74,0x68,0xa3,0x41,0x12,0x61,0x70,0x68,0xa3,0x43,0x14,
+0x61,0x6d,0x65,0x64,0x68,0xa3,0x44,0x61,0x34,0x62,0x4a,0x64,0x50,0x66,0x12,0x69,
+0x76,0x65,0x9f,1,0x6c,0x2a,0x79,0x11,0x69,0x6e,0x97,0x12,0x65,0x70,0x68,0x95,
+0x12,0x65,0x74,0x68,0x99,1,0x61,0x30,0x68,0x14,0x61,0x6d,0x65,0x64,0x68,0x9d,
+0x13,0x6c,0x65,0x74,0x68,0x9b,0x15,0x61,0x79,0x61,0x6c,0x61,0x6d,6,0x6e,0x2c,
+0x6e,0x34,0x72,0x5e,0x73,0x62,0x74,0x11,0x74,0x61,0xa3,0x63,2,0x67,0x2e,0x6e,
+0x32,0x79,0x10,0x61,0xa3,0x60,0x10,0x61,0xa3,0x5d,1,0x61,0xa3,0x5e,0x6e,0x10,
+0x61,0xa3,0x5f,0x10,0x61,0xa3,0x61,0x11,0x73,0x61,0xa3,0x62,0x62,0x3c,0x6a,0x42,
+0x6c,0x10,0x6c,1,0x61,0xa3,0x5b,0x6c,0x10,0x61,0xa3,0x5c,0x11,0x68,0x61,0xa3,
+0x59,0x10,0x61,0xa3,0x5a,0x11,0x65,0x6d,0x51,2,0x6f,0x2c,0x75,0x50,0x79,0x10,
+0x61,0x91,1,0x6a,0x28,0x6f,0x10,0x6e,0x55,0x1a,0x6f,0x69,0x6e,0x69,0x6e,0x67,
+0x67,0x72,0x6f,0x75,0x70,0x21,0x10,0x6e,0x57,0x10,0x65,0x59,0x10,0x61,1,0x66,
+0x5b,0x70,0x10,0x68,0x5d,0x66,0x9a,0x66,0x42,0x67,0x7a,0x68,0x8a,0x6b,0xa2,0x75,
+0x6c,0x11,0x61,0x6d,0x4c,0x12,0x61,0x64,0x68,0x4f,2,0x61,0x3e,0x65,0x4a,0x69,
+0x19,0x6e,0x61,0x6c,0x73,0x65,0x6d,0x6b,0x61,0x74,0x68,0x35,0x15,0x72,0x73,0x69,
+0x79,0x65,0x68,0x8f,0x86,0x10,0x68,0x33,0x10,0x61,1,0x66,0x37,0x6d,0x11,0x61,
+0x6c,0x39,1,0x61,0x40,0x65,0x3e,1,0x68,0x28,0x74,0x10,0x68,0x45,0x40,0x13,
+0x67,0x6f,0x61,0x6c,0x43,2,0x68,0x3b,0x6d,0x5c,0x6e,0x1a,0x69,0x66,0x69,0x72,
+0x6f,0x68,0x69,0x6e,0x67,0x79,0x61,1,0x6b,0x2a,0x70,0x10,0x61,0xa3,0x65,0x15,
+0x69,0x6e,0x6e,0x61,0x79,0x61,0xa3,0x64,0x1a,0x7a,0x61,0x6f,0x6e,0x68,0x65,0x68,
+0x67,0x6f,0x61,0x6c,0x3d,2,0x61,0x3a,0x68,0x44,0x6e,0x17,0x6f,0x74,0x74,0x65,
+0x64,0x68,0x65,0x68,0x4b,1,0x66,0x47,0x70,0x10,0x68,0x49,0x12,0x61,0x70,0x68,
+0x89,0x61,0x2e,0x62,0x8a,0x64,0xa2,0x51,0x65,0x31,2,0x66,0x3c,0x69,0x70,0x6c,
+1,0x61,0x28,0x65,0x10,0x66,0x27,0x11,0x70,0x68,0x25,0x14,0x72,0x69,0x63,0x61,
+0x6e,2,0x66,0x30,0x6e,0x36,0x71,0x11,0x61,0x66,0xa3,0x58,0x11,0x65,0x68,0xa3,
+0x56,0x12,0x6f,0x6f,0x6e,0xa3,0x57,0x10,0x6e,0x23,1,0x65,0x4a,0x75,0x10,0x72,
+0x1f,0x75,0x73,0x68,0x61,0x73,0x6b,0x69,0x79,0x65,0x68,0x62,0x61,0x72,0x72,0x65,
+0x65,0x8d,1,0x68,0x29,0x74,0x10,0x68,0x2b,0x11,0x61,0x6c,0x2c,0x16,0x61,0x74,
+0x68,0x72,0x69,0x73,0x68,0x2f,7,0x6e,0x2e,0x6e,0x2c,0x72,0x3e,0x74,0x56,0x75,
+0x21,0x18,0x6f,0x6e,0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x21,0x28,0x1a,0x69,0x67,
+0x68,0x74,0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x29,0x2a,0x19,0x72,0x61,0x6e,0x73,
+0x70,0x61,0x72,0x65,0x6e,0x74,0x2b,0x63,0x23,0x64,0x40,0x6a,0x56,0x6c,0x26,0x19,
+0x65,0x66,0x74,0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x27,0x24,0x19,0x75,0x61,0x6c,
+0x6a,0x6f,0x69,0x6e,0x69,0x6e,0x67,0x25,0x19,0x6f,0x69,0x6e,0x63,0x61,0x75,0x73,
+0x69,0x6e,0x67,0x23,0,0x13,0x6e,0xc0,0xd0,0x73,0x49,0x73,0x48,0x75,0x78,0x77,
+0x84,0x78,0x9c,0x7a,0x10,0x77,0x58,1,0x6a,0x75,0x73,0x13,0x70,0x61,0x63,0x65,
+0x59,4,0x61,0x51,0x67,0x53,0x70,0x28,0x75,0x30,0x79,0x57,0x54,0x12,0x61,0x63,
+0x65,0x55,0x16,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0x53,0x15,0x6e,0x6b,0x6e,0x6f,
+0x77,0x6e,0x21,1,0x6a,0x5d,0x6f,0x17,0x72,0x64,0x6a,0x6f,0x69,0x6e,0x65,0x72,
+0x5d,0x10,0x78,0x21,0x6e,0x60,0x6f,0xa2,0x41,0x70,0xa2,0x50,0x71,0xa2,0x6e,0x72,
+1,0x65,0x24,0x69,0x6f,0x1e,0x67,0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,
+0x63,0x61,0x74,0x6f,0x72,0x6f,4,0x65,0x3e,0x6c,0x5b,0x6f,0x46,0x73,0x45,0x75,
+0x46,0x14,0x6d,0x65,0x72,0x69,0x63,0x47,0x15,0x78,0x74,0x6c,0x69,0x6e,0x65,0x5b,
+0x17,0x6e,0x73,0x74,0x61,0x72,0x74,0x65,0x72,0x45,0x10,0x70,0x48,0x1c,0x65,0x6e,
+0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0x49,1,0x6f,0x3e,0x72,
+0x4c,0x1a,0x65,0x66,0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x4d,0x4a,0x1b,
+0x73,0x74,0x66,0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,0x69,0x63,0x4b,0x10,0x75,0x4e,
+0x16,0x6f,0x74,0x61,0x74,0x69,0x6f,0x6e,0x4f,0x68,0x7b,0x68,0x50,0x69,0x86,0x6a,
+0xa2,0x61,0x6c,0xa2,0x65,0x6d,0x1c,0x61,0x6e,0x64,0x61,0x74,0x6f,0x72,0x79,0x62,
+0x72,0x65,0x61,0x6b,0x2d,4,0x32,0x5f,0x33,0x61,0x65,0x34,0x6c,0x6d,0x79,0x3a,
+0x13,0x70,0x68,0x65,0x6e,0x3b,0x19,0x62,0x72,0x65,0x77,0x6c,0x65,0x74,0x74,0x65,
+0x72,0x6d,2,0x64,0x28,0x6e,0x3c,0x73,0x41,0x3c,0x18,0x65,0x6f,0x67,0x72,0x61,
+0x70,0x68,0x69,0x63,0x3d,0x3e,1,0x66,0x3e,0x73,0x11,0x65,0x70,1,0x61,0x22,
+0x65,0x14,0x72,0x61,0x62,0x6c,0x65,0x3f,0x18,0x69,0x78,0x6e,0x75,0x6d,0x65,0x72,
+0x69,0x63,0x41,2,0x6c,0x63,0x74,0x65,0x76,0x67,1,0x66,0x43,0x69,0x15,0x6e,
+0x65,0x66,0x65,0x65,0x64,0x43,0x61,0x40,0x62,0x70,0x63,0xa2,0x55,0x65,0xa2,0xdb,
+0x67,0x10,0x6c,0x38,0x11,0x75,0x65,0x39,2,0x69,0x23,0x6c,0x34,0x6d,0x16,0x62,
+0x69,0x67,0x75,0x6f,0x75,0x73,0x23,0x24,0x17,0x70,0x68,0x61,0x62,0x65,0x74,0x69,
+0x63,0x25,4,0x32,0x27,0x61,0x29,0x62,0x2b,0x6b,0x2d,0x72,0x12,0x65,0x61,0x6b,
+2,0x61,0x36,0x62,0x3e,0x73,0x15,0x79,0x6d,0x62,0x6f,0x6c,0x73,0x57,0x13,0x66,
+0x74,0x65,0x72,0x29,1,0x65,0x2a,0x6f,0x11,0x74,0x68,0x27,0x13,0x66,0x6f,0x72,
+0x65,0x2b,7,0x6d,0x51,0x6d,0x33,0x6f,0x28,0x70,0x69,0x72,0x35,1,0x6d,0x76,
+0x6e,1,0x64,0x3c,0x74,0x1a,0x69,0x6e,0x67,0x65,0x6e,0x74,0x62,0x72,0x65,0x61,
+0x6b,0x2f,0x15,0x69,0x74,0x69,0x6f,0x6e,0x61,0x1f,0x6c,0x6a,0x61,0x70,0x61,0x6e,
+0x65,0x73,0x65,0x73,0x74,0x61,0x72,0x74,0x65,0x72,0x6b,1,0x62,0x3a,0x70,0x19,
+0x6c,0x65,0x78,0x63,0x6f,0x6e,0x74,0x65,0x78,0x74,0x51,0x18,0x69,0x6e,0x69,0x6e,
+0x67,0x6d,0x61,0x72,0x6b,0x33,0x61,0x6a,0x62,0x2f,0x6a,0x6b,0x6c,0x30,0x13,0x6f,
+0x73,0x65,0x70,1,0x61,0x38,0x75,0x18,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,
+0x6e,0x31,0x18,0x72,0x65,0x6e,0x74,0x68,0x65,0x73,0x69,0x73,0x69,0x1b,0x72,0x72,
+0x69,0x61,0x67,0x65,0x72,0x65,0x74,0x75,0x72,0x6e,0x35,2,0x62,0x3e,0x6d,0x46,
+0x78,0x36,0x18,0x63,0x6c,0x61,0x6d,0x61,0x74,0x69,0x6f,0x6e,0x37,0x70,0x12,0x61,
+0x73,0x65,0x71,0x72,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,0x72,0x73,1,0x64,0x42,
+0x6e,1,0x6f,0x32,0x75,0x26,0x14,0x6d,0x65,0x72,0x69,0x63,0x27,0x11,0x6e,0x65,
+0x21,1,0x65,0x2e,0x69,0x24,0x12,0x67,0x69,0x74,0x25,0x22,0x14,0x63,0x69,0x6d,
+0x61,0x6c,0x23,0,0x18,0x6e,0xc3,0xe6,0x74,0xc1,0x51,0x77,0x7a,0x77,0xa2,0x4c,
+0x78,0xa2,0x60,0x79,0xa2,0x6a,0x7a,6,0x73,0x1e,0x73,0x34,0x78,0x42,0x79,0x48,
+0x7a,0x11,0x7a,0x7a,0xa3,0x67,0x10,0x79,1,0x65,0xa3,0xae,0x6d,0xa3,0x81,0x11,
+0x78,0x78,0xa3,0x66,0x11,0x79,0x79,0x21,0x61,0x30,0x69,0x58,0x6d,0x11,0x74,0x68,
+0xa3,0x80,0x10,0x6e,1,0x61,0x26,0x62,0xa3,0xb1,0x1a,0x62,0x61,0x7a,0x61,0x72,
+0x73,0x71,0x75,0x61,0x72,0x65,0xa3,0xb1,0x11,0x6e,0x68,0x23,1,0x61,0x2c,0x6f,
+0x11,0x6c,0x65,0xa3,0x9b,0x11,0x72,0x61,0xa2,0x92,0x15,0x6e,0x67,0x63,0x69,0x74,
+0x69,0xa3,0x92,1,0x70,0x2c,0x73,0x11,0x75,0x78,0xa3,0x65,0x11,0x65,0x6f,0x9b,
+0x10,0x69,0x72,0x11,0x69,0x69,0x73,0x74,0x4a,0x75,0xa2,0xba,0x76,1,0x61,0x2c,
+0x69,0x11,0x73,0x70,0xa3,0x64,0x10,0x69,0xa2,0x63,0x10,0x69,0xa3,0x63,5,0x67,
+0x36,0x67,0x68,0x68,0x6c,0x69,2,0x62,0x3a,0x66,0x4a,0x72,0x10,0x68,0xa2,0x9e,
+0x12,0x75,0x74,0x61,0xa3,0x9e,1,0x65,0x24,0x74,0x6f,0x12,0x74,0x61,0x6e,0x6f,
+0x14,0x69,0x6e,0x61,0x67,0x68,0x99,0x11,0x6c,0x67,0x75,0x10,0x61,1,0x61,0x24,
+0x69,0x6d,0x6a,0x11,0x6e,0x61,0x6b,0x61,0x30,0x65,0xa2,0x5b,0x66,0x11,0x6e,0x67,
+0x99,6,0x6c,0x21,0x6c,0x32,0x6d,0x38,0x6e,0x44,0x76,0x10,0x74,0xa3,0x7f,1,
+0x65,0x89,0x75,0x97,1,0x69,0x24,0x6c,0x67,0x10,0x6c,0x67,0x10,0x67,0xa2,0x9a,
+0x11,0x75,0x74,0xa3,0x9a,0x67,0x36,0x69,0x52,0x6b,0x10,0x72,0xa2,0x99,0x10,0x69,
+0xa3,0x99,1,0x61,0x30,0x62,0x7a,0x13,0x61,0x6e,0x77,0x61,0x7b,0x12,0x6c,0x6f,
+0x67,0x75,2,0x6c,0x32,0x74,0x34,0x76,0x12,0x69,0x65,0x74,0xa3,0x7f,0x10,0x65,
+0x89,0x12,0x68,0x61,0x6d,0xa3,0x6a,1,0x6c,0x2a,0x6e,0x10,0x67,0xa3,0x62,0x10,
+0x75,0x68,0x11,0x67,0x75,0x69,1,0x67,0x32,0x6e,0x14,0x6b,0x6e,0x6f,0x77,0x6e,
+0xa3,0x67,0x11,0x61,0x72,0x8a,0x13,0x69,0x74,0x69,0x63,0x8b,0x71,0xc1,0x13,0x71,
+0xa2,0xde,0x72,0xa2,0xe3,0x73,6,0x69,0x8a,0x69,0x72,0x6f,0xa2,0x4c,0x75,0xa2,
+0x75,0x79,1,0x6c,0x46,0x72,4,0x63,0x65,0x65,0xa3,0x5f,0x69,0x2c,0x6a,0xa3,
+0x60,0x6e,0xa3,0x61,0x11,0x61,0x63,0x65,0x10,0x6f,0x94,0x16,0x74,0x69,0x6e,0x61,
+0x67,0x72,0x69,0x95,2,0x64,0x3c,0x67,0x4c,0x6e,1,0x64,0xa3,0x91,0x68,0x62,
+0x12,0x61,0x6c,0x61,0x63,0x10,0x64,0xa2,0xa6,0x12,0x68,0x61,0x6d,0xa3,0xa6,0x17,
+0x6e,0x77,0x72,0x69,0x74,0x69,0x6e,0x67,0xa3,0x70,2,0x67,0x3a,0x72,0x52,0x79,
+0x10,0x6f,0xa2,0xb0,0x12,0x6d,0x62,0x6f,0xa3,0xb0,1,0x64,0x26,0x6f,0xa3,0xb8,
+0xa2,0xb7,0x12,0x69,0x61,0x6e,0xa3,0xb7,0x10,0x61,0xa2,0x98,0x16,0x73,0x6f,0x6d,
+0x70,0x65,0x6e,0x67,0xa3,0x98,0x11,0x6e,0x64,0xa2,0x71,0x14,0x61,0x6e,0x65,0x73,
+0x65,0xa3,0x71,0x61,0x5c,0x67,0xa2,0x43,0x68,1,0x61,0x2a,0x72,0x10,0x64,0xa3,
+0x97,2,0x72,0x28,0x76,0x30,0x77,0x87,0x12,0x61,0x64,0x61,0xa3,0x97,0x12,0x69,
+0x61,0x6e,0x87,2,0x6d,0x40,0x72,0x58,0x75,0x10,0x72,0xa2,0x6f,0x15,0x61,0x73,
+0x68,0x74,0x72,0x61,0xa3,0x6f,1,0x61,0x26,0x72,0xa3,0x7e,0x14,0x72,0x69,0x74,
+0x61,0x6e,0xa3,0x7e,1,0x61,0xa3,0x5e,0x62,0xa3,0x85,0x11,0x6e,0x77,0xa3,0x70,
+0x11,0x61,0x61,1,0x63,0x2f,0x69,0x23,3,0x65,0x3e,0x6a,0x48,0x6f,0x4e,0x75,
+0x10,0x6e,1,0x69,0x24,0x72,0x61,0x10,0x63,0x61,0x13,0x6a,0x61,0x6e,0x67,0xa3,
+0x6e,0x11,0x6e,0x67,0xa3,0x6e,1,0x68,0x2a,0x72,0x10,0x6f,0xa3,0x5d,0x10,0x67,
+0xa3,0xb6,0x6e,0xa2,0x83,0x6f,0xa2,0xca,0x70,5,0x6c,0x1e,0x6c,0x44,0x72,0x4a,
+0x73,0x1b,0x61,0x6c,0x74,0x65,0x72,0x70,0x61,0x68,0x6c,0x61,0x76,0x69,0xa3,0x7b,
+0x11,0x72,0x64,0xa3,0x5c,0x11,0x74,0x69,0xa3,0x7d,0x61,0x7c,0x65,0xa2,0x54,0x68,
+3,0x61,0x3e,0x6c,0x4e,0x6e,0x5e,0x6f,0x16,0x65,0x6e,0x69,0x63,0x69,0x61,0x6e,
+0xa3,0x5b,0x10,0x67,0xa2,0x5a,0x12,0x73,0x70,0x61,0xa3,0x5a,2,0x69,0xa3,0x7a,
+0x70,0xa3,0x7b,0x76,0xa3,0x7c,0x10,0x78,0xa3,0x5b,2,0x68,0x3e,0x6c,0x50,0x75,
+0x10,0x63,0xa2,0xa5,0x14,0x69,0x6e,0x68,0x61,0x75,0xa3,0xa5,0x17,0x61,0x77,0x68,
+0x68,0x6d,0x6f,0x6e,0x67,0xa3,0x4b,0x10,0x6d,0xa2,0x90,0x14,0x79,0x72,0x65,0x6e,
+0x65,0xa3,0x90,0x11,0x72,0x6d,0xa3,0x59,5,0x6b,0x1e,0x6b,0x32,0x73,0x4a,0x75,
+0x12,0x73,0x68,0x75,0xa3,0x96,1,0x67,0x2e,0x6f,0xa2,0x57,0x10,0x6f,0xa3,0x57,
+0x10,0x62,0xa3,0x84,0x11,0x68,0x75,0xa3,0x96,0x61,0x42,0x62,0x60,0x65,0x10,0x77,
+1,0x61,0xa3,0xaa,0x74,0x14,0x61,0x69,0x6c,0x75,0x65,0x97,1,0x62,0x2a,0x72,
+0x10,0x62,0xa3,0x8e,0x15,0x61,0x74,0x61,0x65,0x61,0x6e,0xa3,0x8f,0x11,0x61,0x74,
+0xa3,0x8f,3,0x67,0x5a,0x6c,0x6c,0x72,0xa2,0x93,0x73,2,0x61,0x36,0x67,0x3c,
+0x6d,0x10,0x61,0x84,0x12,0x6e,0x79,0x61,0x85,0x11,0x67,0x65,0xa3,0xab,0x10,0x65,
+0xa3,0xab,1,0x61,0x2a,0x68,0x11,0x61,0x6d,0x5b,0x10,0x6d,0x5b,1,0x63,0xa2,
+0x60,0x64,5,0x70,0x37,0x70,0x36,0x73,0x54,0x74,0x14,0x75,0x72,0x6b,0x69,0x63,
+0xa3,0x58,0x11,0x65,0x72,1,0x6d,0x2c,0x73,0x12,0x69,0x61,0x6e,0x9b,0x11,0x69,
+0x63,0xa3,0x59,0x10,0x6f,1,0x67,0x3a,0x75,0x18,0x74,0x68,0x61,0x72,0x61,0x62,
+0x69,0x61,0x6e,0xa3,0x85,0x13,0x64,0x69,0x61,0x6e,0xa3,0xb8,0x68,0x42,0x69,0x54,
+0x6e,0x1a,0x6f,0x72,0x74,0x68,0x61,0x72,0x61,0x62,0x69,0x61,0x6e,0xa3,0x8e,0x17,
+0x75,0x6e,0x67,0x61,0x72,0x69,0x61,0x6e,0xa3,0x4c,0x14,0x74,0x61,0x6c,0x69,0x63,
+0x5d,1,0x68,0x26,0x6b,0xa3,0x6d,0x12,0x69,0x6b,0x69,0xa3,0x6d,2,0x69,0x2c,
+0x6b,0x30,0x79,0x10,0x61,0x5f,0x11,0x79,0x61,0x5f,0x10,0x68,0xa3,0x58,0x68,0xc2,
+0xef,0x6b,0xc2,0xa,0x6b,0xa4,0x17,0x6c,0xa4,0x98,0x6d,8,0x6f,0x46,0x6f,0x48,
+0x72,0x74,0x74,0x80,0x75,0x86,0x79,1,0x61,0x28,0x6d,0x10,0x72,0x59,0x13,0x6e,
+0x6d,0x61,0x72,0x59,2,0x64,0x2e,0x6e,0x32,0x6f,0x10,0x6e,0xa3,0x72,0x10,0x69,
+0xa3,0xa3,0x10,0x67,0x56,0x14,0x6f,0x6c,0x69,0x61,0x6e,0x57,0x10,0x6f,0xa2,0x95,
+0x10,0x6f,0xa3,0x95,0x11,0x65,0x69,0xa3,0x73,0x11,0x6c,0x74,0xa2,0xa4,0x12,0x61,
+0x6e,0x69,0xa3,0xa4,0x61,0x36,0x65,0xa2,0x67,0x69,0xa2,0xbd,0x6c,0x11,0x79,0x6d,
+0x55,6,0x6e,0x38,0x6e,0x32,0x72,0x5c,0x73,0x6c,0x79,0x10,0x61,0xa3,0x55,1,
+0x64,0x38,0x69,0xa2,0x79,0x15,0x63,0x68,0x61,0x65,0x61,0x6e,0xa3,0x79,0xa2,0x54,
+0x12,0x61,0x69,0x63,0xa3,0x54,0x10,0x63,0xa2,0xa9,0x12,0x68,0x65,0x6e,0xa3,0xa9,
+0x18,0x61,0x72,0x61,0x6d,0x67,0x6f,0x6e,0x64,0x69,0xa3,0xaf,0x68,0x36,0x6b,0x4c,
+0x6c,0x15,0x61,0x79,0x61,0x6c,0x61,0x6d,0x55,1,0x61,0x26,0x6a,0xa3,0xa0,0x13,
+0x6a,0x61,0x6e,0x69,0xa3,0xa0,0x10,0x61,0xa2,0xb4,0x12,0x73,0x61,0x72,0xa3,0xb4,
+3,0x64,0x78,0x65,0x94,0x6e,0xa2,0x42,0x72,1,0x63,0xa3,0x8d,0x6f,0xa2,0x56,
+0x13,0x69,0x74,0x69,0x63,1,0x63,0x3c,0x68,0x19,0x69,0x65,0x72,0x6f,0x67,0x6c,
+0x79,0x70,0x68,0x73,0xa3,0x56,0x15,0x75,0x72,0x73,0x69,0x76,0x65,0xa3,0x8d,1,
+0x65,0x26,0x66,0xa3,0xb5,0x16,0x66,0x61,0x69,0x64,0x72,0x69,0x6e,0xa3,0xb5,0x17,
+0x74,0x65,0x69,0x6d,0x61,0x79,0x65,0x6b,0xa3,0x73,0x10,0x64,0xa2,0x8c,0x17,0x65,
+0x6b,0x69,0x6b,0x61,0x6b,0x75,0x69,0xa3,0x8c,0x11,0x61,0x6f,0xa3,0x5c,5,0x6f,
+0x14,0x6f,0x30,0x70,0x36,0x74,0x11,0x68,0x69,0xa3,0x78,0x11,0x72,0x65,0xa3,0x77,
+0x11,0x65,0x6c,0xa3,0x8a,0x61,0x2e,0x68,0x98,0x6e,0x11,0x64,0x61,0x4b,4,0x69,
+0x3c,0x6c,0x44,0x6e,0x48,0x74,0x56,0x79,0x13,0x61,0x68,0x6c,0x69,0xa3,0x4f,0x12,
+0x74,0x68,0x69,0xa3,0x78,0x10,0x69,0xa3,0x4f,1,0x61,0x4d,0x6e,0x12,0x61,0x64,
+0x61,0x4b,0x14,0x61,0x6b,0x61,0x6e,0x61,0x4c,0x19,0x6f,0x72,0x68,0x69,0x72,0x61,
+0x67,0x61,0x6e,0x61,0x8d,3,0x61,0x3c,0x6d,0x4e,0x6f,0x5a,0x75,0x15,0x64,0x61,
+0x77,0x61,0x64,0x69,0xa3,0x91,0x10,0x72,0x92,0x15,0x6f,0x73,0x68,0x74,0x68,0x69,
+0x93,1,0x65,0x24,0x72,0x4f,0x10,0x72,0x4f,0x10,0x6a,0xa2,0x9d,0x11,0x6b,0x69,
+0xa3,0x9d,4,0x61,0x5c,0x65,0x90,0x69,0xa0,0x6f,0xa2,0x5d,0x79,1,0x63,0x34,
+0x64,0x10,0x69,0xa2,0x6c,0x11,0x61,0x6e,0xa3,0x6c,0x10,0x69,0xa2,0x6b,0x11,0x61,
+0x6e,0xa3,0x6b,2,0x6e,0x42,0x6f,0x46,0x74,3,0x66,0xa3,0x50,0x67,0xa3,0x51,
+0x69,0x24,0x6e,0x53,0x10,0x6e,0x53,0x10,0x61,0xa3,0x6a,0x50,0x10,0x6f,0x51,0x11,
+0x70,0x63,0xa2,0x52,0x11,0x68,0x61,0xa3,0x52,2,0x6d,0x2e,0x6e,0x36,0x73,0x10,
+0x75,0xa3,0x83,0x10,0x62,0x80,0x10,0x75,0x81,2,0x61,0xa3,0x53,0x62,0x83,0x65,
+0x11,0x61,0x72,1,0x61,0xa3,0x53,0x62,0x83,0x11,0x6d,0x61,0xa3,0x8b,0x68,0x6e,
+0x69,0xa2,0x91,0x6a,2,0x61,0x30,0x70,0x52,0x75,0x11,0x72,0x63,0xa3,0x94,1,
+0x6d,0x38,0x76,0x10,0x61,0xa2,0x4e,0x13,0x6e,0x65,0x73,0x65,0xa3,0x4e,0x10,0x6f,
+0xa3,0xad,0x11,0x61,0x6e,0xa3,0x69,6,0x6c,0x1a,0x6c,0x34,0x6d,0x3a,0x72,0x40,
+0x75,0x11,0x6e,0x67,0xa3,0x4c,0x11,0x75,0x77,0xa3,0x9c,0x11,0x6e,0x67,0xa3,0x4b,
+0x11,0x6b,0x74,0x8d,0x61,0x3c,0x65,0xa2,0x43,0x69,0x11,0x72,0x61,0x48,0x13,0x67,
+0x61,0x6e,0x61,0x49,1,0x6e,0x34,0x74,0x10,0x72,0xa2,0xa2,0x11,0x61,0x6e,0xa3,
+0xa2,0x42,6,0x6f,0xe,0x6f,0x77,0x73,0xa3,0x49,0x74,0xa3,0x4a,0x75,0x12,0x6e,
+0x6f,0x6f,0x77,0x62,0xa3,0xac,0x67,0x3e,0x69,0x42,0x19,0x66,0x69,0x72,0x6f,0x68,
+0x69,0x6e,0x67,0x79,0x61,0xa3,0xb6,0x44,0x11,0x75,0x6c,0x45,0x11,0x62,0x72,0x46,
+0x11,0x65,0x77,0x47,2,0x6d,0x2e,0x6e,0x4a,0x74,0x11,0x61,0x6c,0x5d,0x1c,0x70,
+0x65,0x72,0x69,0x61,0x6c,0x61,0x72,0x61,0x6d,0x61,0x69,0x63,0xa3,0x74,2,0x64,
+0x66,0x68,0x6a,0x73,0x1b,0x63,0x72,0x69,0x70,0x74,0x69,0x6f,0x6e,0x61,0x6c,0x70,
+0x61,1,0x68,0x32,0x72,0x14,0x74,0x68,0x69,0x61,0x6e,0xa3,0x7d,0x13,0x6c,0x61,
+0x76,0x69,0xa3,0x7a,0x10,0x73,0xa3,0x4d,0x15,0x65,0x72,0x69,0x74,0x65,0x64,0x23,
+0x64,0xc0,0xec,0x64,0xa2,0x7a,0x65,0xa2,0xad,0x67,4,0x65,0x82,0x6c,0x9a,0x6f,
+0xa2,0x46,0x72,0xa2,0x55,0x75,2,0x6a,0x3c,0x6e,0x4e,0x72,1,0x6d,0x24,0x75,
+0x41,0x13,0x75,0x6b,0x68,0x69,0x41,1,0x61,0x24,0x72,0x3f,0x13,0x72,0x61,0x74,
+0x69,0x3f,0x18,0x6a,0x61,0x6c,0x61,0x67,0x6f,0x6e,0x64,0x69,0xa3,0xb3,0x10,0x6f,
+1,0x6b,0xa3,0x48,0x72,0x38,0x13,0x67,0x69,0x61,0x6e,0x39,0x11,0x61,0x67,0x90,
+0x15,0x6f,0x6c,0x69,0x74,0x69,0x63,0x91,1,0x6e,0x30,0x74,0x10,0x68,0x3a,0x11,
+0x69,0x63,0x3b,1,0x67,0xa3,0xb3,0x6d,0xa3,0xaf,1,0x61,0x32,0x65,1,0x65,
+0x24,0x6b,0x3d,0x10,0x6b,0x3d,0x10,0x6e,0xa2,0x89,0x12,0x74,0x68,0x61,0xa3,0x89,
+3,0x65,0x42,0x6f,0x68,0x73,0x76,0x75,0x11,0x70,0x6c,0xa2,0x87,0x13,0x6f,0x79,
+0x61,0x6e,0xa3,0x87,1,0x73,0x38,0x76,0x10,0x61,0x34,0x15,0x6e,0x61,0x67,0x61,
+0x72,0x69,0x35,0x13,0x65,0x72,0x65,0x74,0x33,0x11,0x67,0x72,0xa2,0xb2,0x10,0x61,
+0xa3,0xb2,0x11,0x72,0x74,0x33,2,0x67,0x3a,0x6c,0x72,0x74,0x11,0x68,0x69,0x36,
+0x13,0x6f,0x70,0x69,0x63,0x37,0x10,0x79,2,0x64,0xa3,0x45,0x68,0xa3,0x46,0x70,
+0xa2,0x47,0x1e,0x74,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,0x67,0x6c,0x79,0x70,
+0x68,0x73,0xa3,0x47,0x11,0x62,0x61,0xa2,0x88,0x12,0x73,0x61,0x6e,0xa3,0x88,0x61,
+0xa2,0xa2,0x62,0xa4,7,0x63,6,0x6f,0x3d,0x6f,0x5a,0x70,0x76,0x75,0x7a,0x79,
+1,0x70,0x3e,0x72,2,0x69,0x2a,0x6c,0x31,0x73,0xa3,0x44,0x13,0x6c,0x6c,0x69,
+0x63,0x31,0x13,0x72,0x69,0x6f,0x74,0x7f,1,0x6d,0x30,0x70,0x10,0x74,0x2e,0x11,
+0x69,0x63,0x2f,0x12,0x6d,0x6f,0x6e,0x21,0x11,0x72,0x74,0x7f,0x16,0x6e,0x65,0x69,
+0x66,0x6f,0x72,0x6d,0xa3,0x65,0x61,0x32,0x68,0xa2,0x41,0x69,0x11,0x72,0x74,0xa3,
+0x43,3,0x6b,0x4c,0x6e,0x50,0x72,0x76,0x75,0x1d,0x63,0x61,0x73,0x69,0x61,0x6e,
+0x61,0x6c,0x62,0x61,0x6e,0x69,0x61,0x6e,0xa3,0x9f,0x10,0x6d,0xa3,0x76,1,0x61,
+0x24,0x73,0x71,0x1d,0x64,0x69,0x61,0x6e,0x61,0x62,0x6f,0x72,0x69,0x67,0x69,0x6e,
+0x61,0x6c,0x71,0x10,0x69,0xa2,0x68,0x11,0x61,0x6e,0xa3,0x68,1,0x61,0x34,0x65,
+0x10,0x72,0x2c,0x13,0x6f,0x6b,0x65,0x65,0x2d,1,0x6b,0x26,0x6d,0xa3,0x42,0x11,
+0x6d,0x61,0xa3,0x76,6,0x68,0x4a,0x68,0x48,0x6e,0x4e,0x72,0x76,0x76,1,0x65,
+0x2a,0x73,0x10,0x74,0xa3,0x75,0x13,0x73,0x74,0x61,0x6e,0xa3,0x75,0x11,0x6f,0x6d,
+0xa3,0xa1,0x11,0x61,0x74,0x1f,0x6f,0x6c,0x69,0x61,0x6e,0x68,0x69,0x65,0x72,0x6f,
+0x67,0x6c,0x79,0x70,0x68,0x73,0xa3,0x9c,1,0x61,0x3e,0x6d,2,0x65,0x2a,0x69,
+0xa3,0x74,0x6e,0x27,0x13,0x6e,0x69,0x61,0x6e,0x27,0x10,0x62,0x24,0x11,0x69,0x63,
+0x25,0x64,0x30,0x66,0x44,0x67,0x11,0x68,0x62,0xa3,0x9f,0x10,0x6c,1,0x61,0x26,
+0x6d,0xa3,0xa7,0x10,0x6d,0xa3,0xa7,0x11,0x61,0x6b,0xa3,0x93,6,0x6c,0x3c,0x6c,
+0x52,0x6f,0x56,0x72,0x66,0x75,1,0x67,0x30,0x68,1,0x64,0x79,0x69,0x10,0x64,
+0x79,0x10,0x69,0x8e,0x13,0x6e,0x65,0x73,0x65,0x8f,0x11,0x69,0x73,0xa1,0x11,0x70,
+0x6f,0x2a,0x13,0x6d,0x6f,0x66,0x6f,0x2b,0x10,0x61,1,0x68,0x2e,0x69,0x7c,0x12,
+0x6c,0x6c,0x65,0x7d,0xa2,0x41,0x11,0x6d,0x69,0xa3,0x41,0x61,0x48,0x65,0x9c,0x68,
+1,0x61,0x2a,0x6b,0x10,0x73,0xa3,0xa8,0x15,0x69,0x6b,0x73,0x75,0x6b,0x69,0xa3,
+0xa8,3,0x6c,0x3a,0x6d,0x48,0x73,0x54,0x74,1,0x61,0x24,0x6b,0x9f,0x10,0x6b,
+0x9f,0x10,0x69,0x9c,0x13,0x6e,0x65,0x73,0x65,0x9d,0x10,0x75,0xa2,0x82,0x10,0x6d,
+0xa3,0x82,0x10,0x73,0xa2,0x86,0x13,0x61,0x76,0x61,0x68,0xa3,0x86,0x11,0x6e,0x67,
+0x28,0x12,0x61,0x6c,0x69,0x29,3,0x6c,0x42,0x6e,0x90,0x74,0xa2,0x46,0x76,0x24,
+0x17,0x6f,0x77,0x65,0x6c,0x6a,0x61,0x6d,0x6f,0x25,0x22,1,0x65,0x54,0x76,0x28,
+1,0x73,0x38,0x74,0x2a,0x17,0x73,0x79,0x6c,0x6c,0x61,0x62,0x6c,0x65,0x2b,0x16,
+0x79,0x6c,0x6c,0x61,0x62,0x6c,0x65,0x29,0x18,0x61,0x64,0x69,0x6e,0x67,0x6a,0x61,
+0x6d,0x6f,0x23,1,0x61,0x21,0x6f,0x1a,0x74,0x61,0x70,0x70,0x6c,0x69,0x63,0x61,
+0x62,0x6c,0x65,0x21,0x26,0x1a,0x72,0x61,0x69,0x6c,0x69,0x6e,0x67,0x6a,0x61,0x6d,
+0x6f,0x27,1,0x6e,0x2c,0x79,0x22,0x11,0x65,0x73,0x23,0x20,0x10,0x6f,0x21,1,
+0x6e,0x2c,0x79,0x22,0x11,0x65,0x73,0x23,0x20,0x10,0x6f,0x21,2,0x6d,0x30,0x6e,
+0x3a,0x79,0x22,0x11,0x65,0x73,0x23,0x24,0x13,0x61,0x79,0x62,0x65,0x25,0x20,0x10,
+0x6f,0x21,2,0x6d,0x30,0x6e,0x3a,0x79,0x22,0x11,0x65,0x73,0x23,0x24,0x13,0x61,
+0x79,0x62,0x65,0x25,0x20,0x10,0x6f,0x21,0xb,0x72,0x39,0x76,0xc,0x76,0x33,0x78,
+0x2a,0x7a,0x11,0x77,0x6a,0x43,0x10,0x78,0x21,0x72,0x28,0x73,0x50,0x74,0x31,1,
+0x65,0x24,0x69,0x39,0x1e,0x67,0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,0x63,
+0x61,0x74,0x6f,0x72,0x39,1,0x6d,0x35,0x70,0x18,0x61,0x63,0x69,0x6e,0x67,0x6d,
+0x61,0x72,0x6b,0x35,0x6c,0x1f,0x6c,0x3c,0x6f,0x4a,0x70,1,0x70,0x37,0x72,0x14,
+0x65,0x70,0x65,0x6e,0x64,0x37,0x28,1,0x66,0x2b,0x76,0x2c,0x10,0x74,0x2f,0x13,
+0x74,0x68,0x65,0x72,0x21,0x63,0x4c,0x65,0x64,0x67,1,0x61,0x3a,0x6c,0x19,0x75,
+0x65,0x61,0x66,0x74,0x65,0x72,0x7a,0x77,0x6a,0x41,0x10,0x7a,0x41,2,0x6e,0x23,
+0x6f,0x24,0x72,0x25,0x14,0x6e,0x74,0x72,0x6f,0x6c,0x23,2,0x62,0x34,0x6d,0x4e,
+0x78,0x26,0x13,0x74,0x65,0x6e,0x64,0x27,0x3a,1,0x61,0x24,0x67,0x3d,0x11,0x73,
+0x65,0x3a,0x12,0x67,0x61,0x7a,0x3d,0x3e,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,0x72,
+0x3f,9,0x6e,0x4a,0x6e,0x34,0x6f,0x44,0x73,0x60,0x75,0x94,0x78,0x10,0x78,0x21,
+0x10,0x75,0x2a,0x14,0x6d,0x65,0x72,0x69,0x63,0x2b,1,0x6c,0x2c,0x74,0x12,0x68,
+0x65,0x72,0x21,0x14,0x65,0x74,0x74,0x65,0x72,0x2d,3,0x63,0x36,0x65,0x46,0x70,
+0x31,0x74,0x32,0x12,0x65,0x72,0x6d,0x33,0x3c,0x16,0x6f,0x6e,0x74,0x69,0x6e,0x75,
+0x65,0x3d,0x2e,0x10,0x70,0x2f,0x10,0x70,0x34,0x12,0x70,0x65,0x72,0x35,0x61,0x46,
+0x63,0x52,0x65,0x64,0x66,0x72,0x6c,2,0x65,0x2d,0x66,0x3b,0x6f,0x28,0x12,0x77,
+0x65,0x72,0x29,0x10,0x74,0x22,0x12,0x65,0x72,0x6d,0x23,1,0x6c,0x24,0x72,0x37,
+0x24,0x12,0x6f,0x73,0x65,0x25,0x10,0x78,0x38,0x13,0x74,0x65,0x6e,0x64,0x39,0x10,
+0x6f,0x26,0x13,0x72,0x6d,0x61,0x74,0x27,0,0x10,0x6c,0x88,0x72,0x40,0x72,0x36,
+0x73,0x5e,0x77,0x7a,0x78,0x8a,0x7a,0x11,0x77,0x6a,0x4b,1,0x65,0x24,0x69,0x3b,
+0x1e,0x67,0x69,0x6f,0x6e,0x61,0x6c,0x69,0x6e,0x64,0x69,0x63,0x61,0x74,0x6f,0x72,
+0x3b,1,0x69,0x24,0x71,0x3f,0x18,0x6e,0x67,0x6c,0x65,0x71,0x75,0x6f,0x74,0x65,
+0x3f,0x17,0x73,0x65,0x67,0x73,0x70,0x61,0x63,0x65,0x4d,0x10,0x78,0x21,0x6c,0x36,
+0x6d,0x3c,0x6e,0x76,0x6f,0x13,0x74,0x68,0x65,0x72,0x21,1,0x65,0x23,0x66,0x35,
+3,0x62,0x37,0x69,0x28,0x6c,0x29,0x6e,0x2b,0x10,0x64,1,0x6c,0x34,0x6e,0x11,
+0x75,0x6d,0x2a,0x12,0x6c,0x65,0x74,0x37,0x14,0x65,0x74,0x74,0x65,0x72,0x29,2,
+0x65,0x36,0x6c,0x39,0x75,0x2c,0x14,0x6d,0x65,0x72,0x69,0x63,0x2d,0x14,0x77,0x6c,
+0x69,0x6e,0x65,0x39,0x66,0x3f,0x66,0x40,0x67,0x4e,0x68,0x70,0x6b,0x10,0x61,0x26,
+0x15,0x74,0x61,0x6b,0x61,0x6e,0x61,0x27,0x10,0x6f,0x24,0x13,0x72,0x6d,0x61,0x74,
+0x25,1,0x61,0x3a,0x6c,0x19,0x75,0x65,0x61,0x66,0x74,0x65,0x72,0x7a,0x77,0x6a,
+0x49,0x10,0x7a,0x49,1,0x65,0x24,0x6c,0x3d,0x19,0x62,0x72,0x65,0x77,0x6c,0x65,
+0x74,0x74,0x65,0x72,0x3d,0x61,0x86,0x63,0x92,0x64,0x94,0x65,2,0x62,0x44,0x6d,
+0x5e,0x78,0x2e,0x13,0x74,0x65,0x6e,0x64,0x32,0x15,0x6e,0x75,0x6d,0x6c,0x65,0x74,
+0x2f,0x42,1,0x61,0x24,0x67,0x45,0x11,0x73,0x65,0x42,0x12,0x67,0x61,0x7a,0x45,
+0x46,0x16,0x6f,0x64,0x69,0x66,0x69,0x65,0x72,0x47,0x15,0x6c,0x65,0x74,0x74,0x65,
+0x72,0x23,0x10,0x72,0x31,1,0x6f,0x24,0x71,0x41,0x18,0x75,0x62,0x6c,0x65,0x71,
+0x75,0x6f,0x74,0x65,0x41,2,0x63,0x32,0x6e,0x3c,0x6f,0x22,0x12,0x70,0x65,0x6e,
+0x23,0x24,0x13,0x6c,0x6f,0x73,0x65,0x25,0x20,0x12,0x6f,0x6e,0x65,0x21,0xd,0x6e,
+0xc1,0x86,0x73,0xa8,0x73,0x4c,0x74,0xa2,0x76,0x75,0xa2,0x83,0x7a,0xd8,0x70,0,
+2,0x6c,0xd9,0x20,0,0x70,0xd9,0x40,0,0x73,0xc3,0,0xfe,0xf,0,0,
+0,7,0x6f,0x3c,0x6f,0xff,8,0,0,0,0x70,0x3a,0x75,0x6e,0x79,0x13,
+0x6d,0x62,0x6f,0x6c,0xff,0xf,0,0,0,0x11,0x61,0x63,1,0x65,0x34,0x69,
+0x15,0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa5,0,0x18,0x73,0x65,0x70,0x61,0x72,0x61,
+0x74,0x6f,0x72,0xc3,0,0x16,0x72,0x72,0x6f,0x67,0x61,0x74,0x65,0xe1,0,0,
+0x63,0xff,2,0,0,0,0x65,0x38,0x6b,0xff,4,0,0,0,0x6d,0xff,
+1,0,0,0,0x16,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0xd9,0x70,0,0x1d,
+0x69,0x74,0x6c,0x65,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x31,1,
+0x6e,0x40,0x70,0x1c,0x70,0x65,0x72,0x63,0x61,0x73,0x65,0x6c,0x65,0x74,0x74,0x65,
+0x72,0x25,0x17,0x61,0x73,0x73,0x69,0x67,0x6e,0x65,0x64,0x23,0x6e,0xa2,0x69,0x6f,
+0xa2,0x89,0x70,0xfe,0x30,0xf8,0,0,9,0x69,0x33,0x69,0xff,0x10,0,0,
+0,0x6f,0xfd,0x80,0,0,0x72,0x54,0x73,0xf9,0,0,0x75,0x12,0x6e,0x63,
+0x74,0xfe,0x30,0xf8,0,0,0x15,0x75,0x61,0x74,0x69,0x6f,0x6e,0xff,0x30,0xf8,
+0,0,0x17,0x69,0x76,0x61,0x74,0x65,0x75,0x73,0x65,0xdd,0,0,0x61,0x48,
+0x63,0xfd,0x40,0,0,0x64,0xe9,0,0,0x65,0xfd,0x20,0,0,0x66,0xff,
+0x20,0,0,0,0x1f,0x72,0x61,0x67,0x72,0x61,0x70,0x68,0x73,0x65,0x70,0x61,
+0x72,0x61,0x74,0x6f,0x72,0xd9,0x40,0,0xbe,0,3,0x64,0xa7,0,0x6c,0xab,
+0,0x6f,0x30,0x75,0x13,0x6d,0x62,0x65,0x72,0xbf,0,0xb2,0,0x1b,0x6e,0x73,
+0x70,0x61,0x63,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa1,1,0x70,0x92,0x74,0x12,
+0x68,0x65,0x72,0xe6,0x80,1,3,0x6c,0x40,0x6e,0x4a,0x70,0x56,0x73,0x14,0x79,
+0x6d,0x62,0x6f,0x6c,0xff,8,0,0,0,0x14,0x65,0x74,0x74,0x65,0x72,0x61,
+0x14,0x75,0x6d,0x62,0x65,0x72,0xb3,0,0x19,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,
+0x69,0x6f,0x6e,0xfd,0x80,0,0,0x1c,0x65,0x6e,0x70,0x75,0x6e,0x63,0x74,0x75,
+0x61,0x74,0x69,0x6f,0x6e,0xf9,0,0,0x66,0xc0,0xc4,0x66,0xa2,0x47,0x69,0xa2,
+0x64,0x6c,0xa2,0x79,0x6d,0xa4,0xc0,4,0x61,0x6c,0x63,0xa5,0,0x65,0xa3,0x80,
+0x6e,0xa1,0x6f,0x15,0x64,0x69,0x66,0x69,0x65,0x72,1,0x6c,0x38,0x73,0x14,0x79,
+0x6d,0x62,0x6f,0x6c,0xff,4,0,0,0,0x14,0x65,0x74,0x74,0x65,0x72,0x41,
+1,0x72,0x3c,0x74,0x16,0x68,0x73,0x79,0x6d,0x62,0x6f,0x6c,0xff,1,0,0,
+0,0x10,0x6b,0xa5,0xc0,1,0x69,0x32,0x6f,0x13,0x72,0x6d,0x61,0x74,0xdb,0,
+0,0x1d,0x6e,0x61,0x6c,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,
+0xff,0x20,0,0,0,0x10,0x6e,0x1f,0x69,0x74,0x69,0x61,0x6c,0x70,0x75,0x6e,
+0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xff,0x10,0,0,0,0x9c,7,0x6d,
+0x18,0x6d,0x41,0x6f,0x28,0x74,0x31,0x75,0x25,0x60,0x1c,0x77,0x65,0x72,0x63,0x61,
+0x73,0x65,0x6c,0x65,0x74,0x74,0x65,0x72,0x29,0x63,0x3d,0x65,0x28,0x69,0x42,0x6c,
+0x29,0x13,0x74,0x74,0x65,0x72,0x9c,0x15,0x6e,0x75,0x6d,0x62,0x65,0x72,0xab,0,
+0x1a,0x6e,0x65,0x73,0x65,0x70,0x61,0x72,0x61,0x74,0x6f,0x72,0xd9,0x20,0,0x63,
+0x46,0x64,0xa2,0x96,0x65,0x1b,0x6e,0x63,0x6c,0x6f,0x73,0x69,0x6e,0x67,0x6d,0x61,
+0x72,0x6b,0xa3,0x80,0xe6,0x80,1,7,0x6e,0x57,0x6e,0x52,0x6f,0x5e,0x73,0xe1,
+0,0,0x75,0x1b,0x72,0x72,0x65,0x6e,0x63,0x79,0x73,0x79,0x6d,0x62,0x6f,0x6c,
+0xff,2,0,0,0,0x22,0x12,0x74,0x72,0x6c,0xd9,0x80,0,0xdc,0,0,
+1,0x6d,0x62,0x6e,1,0x6e,0x30,0x74,0x12,0x72,0x6f,0x6c,0xd9,0x80,0,0x1f,
+0x65,0x63,0x74,0x6f,0x72,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,
+0xfd,0x40,0,0,0x19,0x62,0x69,0x6e,0x69,0x6e,0x67,0x6d,0x61,0x72,0x6b,0xa5,
+0xc0,0x61,0x58,0x63,0xd9,0x80,0,0x66,0xdb,0,0,0x6c,0x1d,0x6f,0x73,0x65,
+0x70,0x75,0x6e,0x63,0x74,0x75,0x61,0x74,0x69,0x6f,0x6e,0xfd,0x20,0,0,0x18,
+0x73,0x65,0x64,0x6c,0x65,0x74,0x74,0x65,0x72,0x3d,2,0x61,0x32,0x65,0x50,0x69,
+0x12,0x67,0x69,0x74,0xa7,0,0x1c,0x73,0x68,0x70,0x75,0x6e,0x63,0x74,0x75,0x61,
+0x74,0x69,0x6f,0x6e,0xe9,0,0,0x1a,0x63,0x69,0x6d,0x61,0x6c,0x6e,0x75,0x6d,
+0x62,0x65,0x72,0xa7,0
 };
 
-const char PropNameData::nameGroups[19082]={
+const char PropNameData::nameGroups[19587]={
 2,'A','l','p','h','a',0,'A','l','p','h','a','b','e','t','i','c',0,
 4,'N',0,'N','o',0,'F',0,'F','a','l','s','e',0,4,'Y',0,'Y','e','s',0,'T',0,'T','r','u','e',0,
 2,'N','R',0,'N','o','t','_','R','e','o','r','d','e','r','e','d',0,
@@ -1025,14 +1049,14 @@ const char PropNameData::nameGroups[19082]={
 2,'C','W','C','M',0,'C','h','a','n','g','e','s','_','W','h','e','n','_','C','a','s','e','m','a','p','p','e','d',0,
 2,'C','W','K','C','F',0,'C','h','a','n','g','e','s','_','W','h','e','n','_','N','F','K','C','_','C','a','s','e','f','o','l',
 'd','e','d',0,2,'E','m','o','j','i',0,'E','m','o','j','i',0,
-2,'E','m','o','j','i','_','P','r','e','s','e','n','t','a','t','i','o','n',0,'E','m','o','j','i','_','P','r','e','s','e','n',
-'t','a','t','i','o','n',0,2,'E','m','o','j','i','_','M','o','d','i','f','i','e','r',0,'E','m','o','j','i','_','M','o','d',
-'i','f','i','e','r',0,2,'E','m','o','j','i','_','M','o','d','i','f','i','e','r','_','B','a','s','e',0,
-'E','m','o','j','i','_','M','o','d','i','f','i','e','r','_','B','a','s','e',0,
-2,'E','m','o','j','i','_','C','o','m','p','o','n','e','n','t',0,'E','m','o','j','i','_','C','o','m','p','o','n','e','n','t',
-0,2,'R','I',0,'R','e','g','i','o','n','a','l','_','I','n','d','i','c','a','t','o','r',0,
+2,'E','P','r','e','s',0,'E','m','o','j','i','_','P','r','e','s','e','n','t','a','t','i','o','n',0,
+2,'E','M','o','d',0,'E','m','o','j','i','_','M','o','d','i','f','i','e','r',0,
+2,'E','B','a','s','e',0,'E','m','o','j','i','_','M','o','d','i','f','i','e','r','_','B','a','s','e',0,
+2,'E','C','o','m','p',0,'E','m','o','j','i','_','C','o','m','p','o','n','e','n','t',0,
+2,'R','I',0,'R','e','g','i','o','n','a','l','_','I','n','d','i','c','a','t','o','r',0,
 2,'P','C','M',0,'P','r','e','p','e','n','d','e','d','_','C','o','n','c','a','t','e','n','a','t','i','o','n','_','M','a','r',
-'k',0,2,'b','c',0,'B','i','d','i','_','C','l','a','s','s',0,
+'k',0,2,'E','x','t','P','i','c','t',0,'E','x','t','e','n','d','e','d','_','P','i','c','t','o','g','r','a','p','h','i','c',
+0,2,'b','c',0,'B','i','d','i','_','C','l','a','s','s',0,
 2,'L',0,'L','e','f','t','_','T','o','_','R','i','g','h','t',0,
 2,'R',0,'R','i','g','h','t','_','T','o','_','L','e','f','t',0,
 2,'E','N',0,'E','u','r','o','p','e','a','n','_','N','u','m','b','e','r',0,
@@ -1371,8 +1395,19 @@ const char PropNameData::nameGroups[19082]={
 2,'N','u','s','h','u',0,'N','u','s','h','u',0,2,'S','o','y','o','m','b','o',0,'S','o','y','o','m','b','o',0,
 2,'S','y','r','i','a','c','_','S','u','p',0,'S','y','r','i','a','c','_','S','u','p','p','l','e','m','e','n','t',0,
 2,'Z','a','n','a','b','a','z','a','r','_','S','q','u','a','r','e',0,'Z','a','n','a','b','a','z','a','r','_','S','q','u','a',
-'r','e',0,2,'c','c','c',0,'C','a','n','o','n','i','c','a','l','_','C','o','m','b','i','n','i','n','g','_','C','l','a','s',
-'s',0,2,'d','t',0,'D','e','c','o','m','p','o','s','i','t','i','o','n','_','T','y','p','e',0,
+'r','e',0,2,'C','h','e','s','s','_','S','y','m','b','o','l','s',0,'C','h','e','s','s','_','S','y','m','b','o','l','s',0,
+2,'D','o','g','r','a',0,'D','o','g','r','a',0,2,'G','e','o','r','g','i','a','n','_','E','x','t',0,
+'G','e','o','r','g','i','a','n','_','E','x','t','e','n','d','e','d',0,
+2,'G','u','n','j','a','l','a','_','G','o','n','d','i',0,'G','u','n','j','a','l','a','_','G','o','n','d','i',0,
+2,'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a',0,'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a',
+0,2,'I','n','d','i','c','_','S','i','y','a','q','_','N','u','m','b','e','r','s',0,'I','n','d','i','c','_','S','i','y','a',
+'q','_','N','u','m','b','e','r','s',0,2,'M','a','k','a','s','a','r',0,'M','a','k','a','s','a','r',0,
+2,'M','a','y','a','n','_','N','u','m','e','r','a','l','s',0,'M','a','y','a','n','_','N','u','m','e','r','a','l','s',0,
+2,'M','e','d','e','f','a','i','d','r','i','n',0,'M','e','d','e','f','a','i','d','r','i','n',0,
+2,'O','l','d','_','S','o','g','d','i','a','n',0,'O','l','d','_','S','o','g','d','i','a','n',0,
+2,'S','o','g','d','i','a','n',0,'S','o','g','d','i','a','n',0,
+2,'c','c','c',0,'C','a','n','o','n','i','c','a','l','_','C','o','m','b','i','n','i','n','g','_','C','l','a','s','s',0,
+2,'d','t',0,'D','e','c','o','m','p','o','s','i','t','i','o','n','_','T','y','p','e',0,
 3,'N','o','n','e',0,'N','o','n','e',0,'n','o','n','e',0,
 3,'C','a','n',0,'C','a','n','o','n','i','c','a','l',0,'c','a','n',0,
 3,'C','o','m',0,'C','o','m','p','a','t',0,'c','o','m',0,
@@ -1503,7 +1538,10 @@ const char PropNameData::nameGroups[19082]={
 2,'M','a','l','a','y','a','l','a','m','_','R','a',0,'M','a','l','a','y','a','l','a','m','_','R','a',0,
 2,'M','a','l','a','y','a','l','a','m','_','S','s','a',0,'M','a','l','a','y','a','l','a','m','_','S','s','a',0,
 2,'M','a','l','a','y','a','l','a','m','_','T','t','a',0,'M','a','l','a','y','a','l','a','m','_','T','t','a',0,
-2,'j','t',0,'J','o','i','n','i','n','g','_','T','y','p','e',0,
+2,'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a','_','K','i','n','n','a','_','Y','a',0,
+'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a','_','K','i','n','n','a','_','Y','a',0,
+2,'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a','_','P','a',0,'H','a','n','i','f','i','_','R','o','h','i','n',
+'g','y','a','_','P','a',0,2,'j','t',0,'J','o','i','n','i','n','g','_','T','y','p','e',0,
 2,'U',0,'N','o','n','_','J','o','i','n','i','n','g',0,2,'C',0,'J','o','i','n','_','C','a','u','s','i','n','g',0,
 2,'D',0,'D','u','a','l','_','J','o','i','n','i','n','g',0,
 2,'L',0,'L','e','f','t','_','J','o','i','n','i','n','g',0,
@@ -1644,7 +1682,12 @@ const char PropNameData::nameGroups[19082]={
 2,'H','a','n','b',0,'H','a','n','b',0,2,'J','a','m','o',0,'J','a','m','o',0,
 2,'Z','s','y','e',0,'Z','s','y','e',0,2,'G','o','n','m',0,'M','a','s','a','r','a','m','_','G','o','n','d','i',0,
 2,'S','o','y','o',0,'S','o','y','o','m','b','o',0,2,'Z','a','n','b',0,'Z','a','n','a','b','a','z','a','r','_','S','q',
-'u','a','r','e',0,2,'h','s','t',0,'H','a','n','g','u','l','_','S','y','l','l','a','b','l','e','_','T','y','p','e',0,
+'u','a','r','e',0,2,'D','o','g','r',0,'D','o','g','r','a',0,
+2,'G','o','n','g',0,'G','u','n','j','a','l','a','_','G','o','n','d','i',0,
+2,'M','a','k','a',0,'M','a','k','a','s','a','r',0,2,'M','e','d','f',0,'M','e','d','e','f','a','i','d','r','i','n',0,
+2,'R','o','h','g',0,'H','a','n','i','f','i','_','R','o','h','i','n','g','y','a',0,
+2,'S','o','g','d',0,'S','o','g','d','i','a','n',0,2,'S','o','g','o',0,'O','l','d','_','S','o','g','d','i','a','n',0,
+2,'h','s','t',0,'H','a','n','g','u','l','_','S','y','l','l','a','b','l','e','_','T','y','p','e',0,
 2,'N','A',0,'N','o','t','_','A','p','p','l','i','c','a','b','l','e',0,
 2,'L',0,'L','e','a','d','i','n','g','_','J','a','m','o',0,
 2,'V',0,'V','o','w','e','l','_','J','a','m','o',0,2,'T',0,'T','r','a','i','l','i','n','g','_','J','a','m','o',0,
@@ -1676,6 +1719,7 @@ const char PropNameData::nameGroups[19082]={
 2,'E','x','t','e','n','d',0,'E','x','t','e','n','d',0,2,'M','B',0,'M','i','d','N','u','m','L','e','t',0,
 2,'N','L',0,'N','e','w','l','i','n','e',0,2,'S','Q',0,'S','i','n','g','l','e','_','Q','u','o','t','e',0,
 2,'D','Q',0,'D','o','u','b','l','e','_','Q','u','o','t','e',0,
+2,'W','S','e','g','S','p','a','c','e',0,'W','S','e','g','S','p','a','c','e',0,
 2,'b','p','t',0,'B','i','d','i','_','P','a','i','r','e','d','_','B','r','a','c','k','e','t','_','T','y','p','e',0,
 2,'n',0,'N','o','n','e',0,2,'o',0,'O','p','e','n',0,
 2,'c',0,'C','l','o','s','e',0,2,'g','c','m',0,'G','e','n','e','r','a','l','_','C','a','t','e','g','o','r','y','_','M',
diff --git a/deps/icu-small/source/common/putil.cpp b/deps/icu-small/source/common/putil.cpp
index e367fa6d30e866..a1e16a9cd94387 100644
--- a/deps/icu-small/source/common/putil.cpp
+++ b/deps/icu-small/source/common/putil.cpp
@@ -533,6 +533,28 @@ uprv_fmin(double x, double y)
     return (x > y ? y : x);
 }
 
+U_CAPI UBool U_EXPORT2
+uprv_add32_overflow(int32_t a, int32_t b, int32_t* res) {
+    // NOTE: Some compilers (GCC, Clang) have primitives available, like __builtin_add_overflow.
+    // This function could be optimized by calling one of those primitives.
+    auto a64 = static_cast<int64_t>(a);
+    auto b64 = static_cast<int64_t>(b);
+    int64_t res64 = a64 + b64;
+    *res = static_cast<int32_t>(res64);
+    return res64 != *res;
+}
+
+U_CAPI UBool U_EXPORT2
+uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res) {
+    // NOTE: Some compilers (GCC, Clang) have primitives available, like __builtin_mul_overflow.
+    // This function could be optimized by calling one of those primitives.
+    auto a64 = static_cast<int64_t>(a);
+    auto b64 = static_cast<int64_t>(b);
+    int64_t res64 = a64 * b64;
+    *res = static_cast<int32_t>(res64);
+    return res64 != *res;
+}
+
 /**
  * Truncates the given double.
  * trunc(3.3) = 3.0, trunc (-3.3) = -3.0
diff --git a/deps/icu-small/source/common/putilimp.h b/deps/icu-small/source/common/putilimp.h
index 56ea8df00959d1..023e06879a0655 100644
--- a/deps/icu-small/source/common/putilimp.h
+++ b/deps/icu-small/source/common/putilimp.h
@@ -391,6 +391,32 @@ U_INTERNAL double  U_EXPORT2 uprv_log(double d);
  */
 U_INTERNAL double  U_EXPORT2 uprv_round(double x);
 
+/**
+ * Adds the signed integers a and b, storing the result in res.
+ * Checks for signed integer overflow.
+ * Similar to the GCC/Clang extension __builtin_add_overflow
+ *
+ * @param a The first operand.
+ * @param b The second operand.
+ * @param res a + b
+ * @return true if overflow occurred; false if no overflow occurred.
+ * @internal
+ */
+U_INTERNAL UBool U_EXPORT2 uprv_add32_overflow(int32_t a, int32_t b, int32_t* res);
+
+/**
+ * Multiplies the signed integers a and b, storing the result in res.
+ * Checks for signed integer overflow.
+ * Similar to the GCC/Clang extension __builtin_mul_overflow
+ *
+ * @param a The first multiplicand.
+ * @param b The second multiplicand.
+ * @param res a * b
+ * @return true if overflow occurred; false if no overflow occurred.
+ * @internal
+ */
+U_INTERNAL UBool U_EXPORT2 uprv_mul32_overflow(int32_t a, int32_t b, int32_t* res);
+
 #if 0
 /**
  * Returns the number of digits after the decimal point in a double number x.
diff --git a/deps/icu-small/source/common/rbbi.cpp b/deps/icu-small/source/common/rbbi.cpp
index 69f92d94c602c3..c5ea2770ba9854 100644
--- a/deps/icu-small/source/common/rbbi.cpp
+++ b/deps/icu-small/source/common/rbbi.cpp
@@ -651,7 +651,7 @@ UBool RuleBasedBreakIterator::isBoundary(int32_t offset) {
     }
 
     // Adjust offset to be on a code point boundary and not beyond the end of the text.
-    // Note that isBoundary() is always be false for offsets that are not on code point boundaries.
+    // Note that isBoundary() is always false for offsets that are not on code point boundaries.
     // But we still need the side effect of leaving iteration at the following boundary.
 
     utext_setNativeIndex(&fText, offset);
@@ -937,26 +937,23 @@ int32_t RuleBasedBreakIterator::handleNext() {
 }
 
 
-
 //-----------------------------------------------------------------------------------
 //
-//  handlePrevious()
+//  handleSafePrevious()
 //
 //      Iterate backwards using the safe reverse rules.
-//      The logic of this function is very similar to handleNext(), above.
+//      The logic of this function is similar to handleNext(), but simpler
+//      because the safe table does not require as many options.
 //
 //-----------------------------------------------------------------------------------
-int32_t RuleBasedBreakIterator::handlePrevious(int32_t fromPosition) {
+int32_t RuleBasedBreakIterator::handleSafePrevious(int32_t fromPosition) {
     int32_t             state;
     uint16_t            category        = 0;
-    RBBIRunMode         mode;
     RBBIStateTableRow  *row;
     UChar32             c;
-    LookAheadResults    lookAheadMatches;
     int32_t             result          = 0;
-    int32_t             initialPosition = 0;
 
-    const RBBIStateTable *stateTable = fData->fSafeRevTable;
+    const RBBIStateTable *stateTable = fData->fReverseTable;
     UTEXT_SETNATIVEINDEX(&fText, fromPosition);
     #ifdef RBBI_DEBUG
         if (gTrace) {
@@ -969,54 +966,24 @@ int32_t RuleBasedBreakIterator::handlePrevious(int32_t fromPosition) {
         return BreakIterator::DONE;
     }
 
-    //  Set up the starting char.
-    initialPosition = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
-    result          = initialPosition;
-    c               = UTEXT_PREVIOUS32(&fText);
-
     //  Set the initial state for the state machine
+    c = UTEXT_PREVIOUS32(&fText);
     state = START_STATE;
     row = (RBBIStateTableRow *)
             (stateTable->fTableData + (stateTable->fRowLen * state));
-    category = 3;
-    mode     = RBBI_RUN;
-    if (stateTable->fFlags & RBBI_BOF_REQUIRED) {
-        category = 2;
-        mode     = RBBI_START;
-    }
-
 
     // loop until we reach the start of the text or transition to state 0
     //
-    for (;;) {
-        if (c == U_SENTINEL) {
-            // Reached end of input string.
-            if (mode == RBBI_END) {
-                // We have already run the loop one last time with the
-                //   character set to the psueudo {eof} value.  Now it is time
-                //   to unconditionally bail out.
-                break;
-            }
-            // Run the loop one last time with the fake end-of-input character category.
-            mode = RBBI_END;
-            category = 1;
-        }
+    for (; c != U_SENTINEL; c = UTEXT_PREVIOUS32(&fText)) {
 
+        // look up the current character's character category, which tells us
+        // which column in the state table to look at.
+        // Note:  the 16 in UTRIE_GET16 refers to the size of the data being returned,
+        //        not the size of the character going in, which is a UChar32.
         //
-        // Get the char category.  An incoming category of 1 or 2 means that
-        //      we are preset for doing the beginning or end of input, and
-        //      that we shouldn't get a category from an actual text input character.
-        //
-        if (mode == RBBI_RUN) {
-            // look up the current character's character category, which tells us
-            // which column in the state table to look at.
-            // Note:  the 16 in UTRIE_GET16 refers to the size of the data being returned,
-            //        not the size of the character going in, which is a UChar32.
-            //
-            //  And off the dictionary flag bit. For reverse iteration it is not used.
-            category = UTRIE2_GET16(fData->fTrie, c);
-            category &= ~0x4000;
-        }
+        //  And off the dictionary flag bit. For reverse iteration it is not used.
+        category = UTRIE2_GET16(fData->fTrie, c);
+        category &= ~0x4000;
 
         #ifdef RBBI_DEBUG
             if (gTrace) {
@@ -1032,65 +999,21 @@ int32_t RuleBasedBreakIterator::handlePrevious(int32_t fromPosition) {
 
         // State Transition - move machine to its next state
         //
-
         // fNextState is a variable-length array.
         U_ASSERT(category<fData->fHeader->fCatCount);
         state = row->fNextState[category];  /*Not accessing beyond memory*/
         row = (RBBIStateTableRow *)
             (stateTable->fTableData + (stateTable->fRowLen * state));
 
-        if (row->fAccepting == -1) {
-            // Match found, common case.
-            result = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
-        }
-
-        int16_t completedRule = row->fAccepting;
-        if (completedRule > 0) {
-            // Lookahead match is completed.
-            int32_t lookaheadResult = lookAheadMatches.getPosition(completedRule);
-            if (lookaheadResult >= 0) {
-                UTEXT_SETNATIVEINDEX(&fText, lookaheadResult);
-                return lookaheadResult;
-            }
-        }
-        int16_t rule = row->fLookAhead;
-        if (rule != 0) {
-            // At the position of a '/' in a look-ahead match. Record it.
-            int32_t  pos = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
-            lookAheadMatches.setPosition(rule, pos);
-        }
-
         if (state == STOP_STATE) {
             // This is the normal exit from the lookup state machine.
-            // We have advanced through the string until it is certain that no
-            //   longer match is possible, no matter what characters follow.
+            // Transistion to state zero means we have found a safe point.
             break;
         }
-
-        // Move (backwards) to the next character to process.
-        // If this is a beginning-of-input loop iteration, don't advance
-        //    the input position.  The next iteration will be processing the
-        //    first real input character.
-        if (mode == RBBI_RUN) {
-            c = UTEXT_PREVIOUS32(&fText);
-        } else {
-            if (mode == RBBI_START) {
-                mode = RBBI_RUN;
-            }
-        }
     }
 
     // The state machine is done.  Check whether it found a match...
-
-    // If the iterator failed to advance in the match engine, force it ahead by one.
-    //   (This really indicates a defect in the break rules.  They should always match
-    //    at least one character.)
-    if (result == initialPosition) {
-        UTEXT_SETNATIVEINDEX(&fText, initialPosition);
-        UTEXT_PREVIOUS32(&fText);
-        result = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
-    }
-
+    result = (int32_t)UTEXT_GETNATIVEINDEX(&fText);
     #ifdef RBBI_DEBUG
         if (gTrace) {
             RBBIDebugPrintf("result = %d\n\n", result);
@@ -1099,7 +1022,6 @@ int32_t RuleBasedBreakIterator::handlePrevious(int32_t fromPosition) {
     return result;
 }
 
-
 //-------------------------------------------------------------------------------
 //
 //   getRuleStatus()   Return the break rule tag associated with the current
diff --git a/deps/icu-small/source/common/rbbi_cache.cpp b/deps/icu-small/source/common/rbbi_cache.cpp
index ba9329d4771321..60316ce6420dc5 100644
--- a/deps/icu-small/source/common/rbbi_cache.cpp
+++ b/deps/icu-small/source/common/rbbi_cache.cpp
@@ -354,14 +354,31 @@ UBool RuleBasedBreakIterator::BreakCache::populateNear(int32_t position, UErrorC
     if ((position < fBoundaries[fStartBufIdx] - 15) || position > (fBoundaries[fEndBufIdx] + 15)) {
         int32_t aBoundary = 0;
         int32_t ruleStatusIndex = 0;
-        // TODO: check for position == length of text. Although may still need to back up to get rule status.
         if (position > 20) {
-            int32_t backupPos = fBI->handlePrevious(position);
-            fBI->fPosition = backupPos;
-            aBoundary = fBI->handleNext();                // Ignore dictionary, just finding a rule based boundary.
-            ruleStatusIndex = fBI->fRuleStatusIndex;
+            int32_t backupPos = fBI->handleSafePrevious(position);
+
+            if (backupPos > 0) {
+                // Advance to the boundary following the backup position.
+                // There is a complication: the safe reverse rules identify pairs of code points
+                // that are safe. If advancing from the safe point moves forwards by less than
+                // two code points, we need to advance one more time to ensure that the boundary
+                // is good, including a correct rules status value.
+                //
+                fBI->fPosition = backupPos;
+                aBoundary = fBI->handleNext();
+                if (aBoundary <= backupPos + 4) {
+                    // +4 is a quick test for possibly having advanced only one codepoint.
+                    // Four being the length of the longest potential code point, a supplementary in UTF-8
+                    utext_setNativeIndex(&fBI->fText, aBoundary);
+                    if (backupPos == utext_getPreviousNativeIndex(&fBI->fText)) {
+                        // The initial handleNext() only advanced by a single code point. Go again.
+                        aBoundary = fBI->handleNext();   // Safe rules identify safe pairs.
+                    }
+                }
+                ruleStatusIndex = fBI->fRuleStatusIndex;
+            }
         }
-        reset(aBoundary, ruleStatusIndex);               // Reset cache to hold aBoundary as a single starting point.
+        reset(aBoundary, ruleStatusIndex);        // Reset cache to hold aBoundary as a single starting point.
     }
 
     // Fill in boundaries between existing cache content and the new requested position.
@@ -485,16 +502,30 @@ UBool RuleBasedBreakIterator::BreakCache::populatePreceding(UErrorCode &status)
         if (backupPosition <= 0) {
             backupPosition = 0;
         } else {
-            backupPosition = fBI->handlePrevious(backupPosition);
+            backupPosition = fBI->handleSafePrevious(backupPosition);
         }
         if (backupPosition == UBRK_DONE || backupPosition == 0) {
             position = 0;
             positionStatusIdx = 0;
         } else {
-            fBI->fPosition = backupPosition;  // TODO: pass starting position in a clearer way.
+            // Advance to the boundary following the backup position.
+            // There is a complication: the safe reverse rules identify pairs of code points
+            // that are safe. If advancing from the safe point moves forwards by less than
+            // two code points, we need to advance one more time to ensure that the boundary
+            // is good, including a correct rules status value.
+            //
+            fBI->fPosition = backupPosition;
             position = fBI->handleNext();
+            if (position <= backupPosition + 4) {
+                // +4 is a quick test for possibly having advanced only one codepoint.
+                // Four being the length of the longest potential code point, a supplementary in UTF-8
+                utext_setNativeIndex(&fBI->fText, position);
+                if (backupPosition == utext_getPreviousNativeIndex(&fBI->fText)) {
+                    // The initial handleNext() only advanced by a single code point. Go again.
+                    position = fBI->handleNext();   // Safe rules identify safe pairs.
+                }
+            };
             positionStatusIdx = fBI->fRuleStatusIndex;
-
         }
     } while (position >= fromPosition);
 
diff --git a/deps/icu-small/source/common/rbbidata.cpp b/deps/icu-small/source/common/rbbidata.cpp
index 18912a6a7b3dcf..fdcb564961362e 100644
--- a/deps/icu-small/source/common/rbbidata.cpp
+++ b/deps/icu-small/source/common/rbbidata.cpp
@@ -81,8 +81,6 @@ void RBBIDataWrapper::init0() {
     fHeader = NULL;
     fForwardTable = NULL;
     fReverseTable = NULL;
-    fSafeFwdTable = NULL;
-    fSafeRevTable = NULL;
     fRuleSource   = NULL;
     fRuleStatusTable = NULL;
     fTrie         = NULL;
@@ -111,21 +109,6 @@ void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) {
     if (data->fRTableLen != 0) {
         fReverseTable = (RBBIStateTable *)((char *)data + fHeader->fRTable);
     }
-    if (data->fSFTableLen != 0) {
-        fSafeFwdTable = (RBBIStateTable *)((char *)data + fHeader->fSFTable);
-    }
-    if (data->fSRTableLen != 0) {
-        fSafeRevTable = (RBBIStateTable *)((char *)data + fHeader->fSRTable);
-    }
-
-    // Rule Compatibility Hacks
-    //    If a rule set includes reverse rules but does not explicitly include safe reverse rules,
-    //    the reverse rules are to be treated as safe reverse rules.
-
-    if (fSafeRevTable == NULL && fReverseTable != NULL) {
-        fSafeRevTable = fReverseTable;
-        fReverseTable = NULL;
-    }
 
     fTrie = utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS,
                                       (uint8_t *)data + fHeader->fTrie,
@@ -277,8 +260,6 @@ void  RBBIDataWrapper::printData() {
 
     printTable("Forward State Transition Table", fForwardTable);
     printTable("Reverse State Transition Table", fReverseTable);
-    printTable("Safe Forward State Transition Table", fSafeFwdTable);
-    printTable("Safe Reverse State Transition Table", fSafeRevTable);
 
     RBBIDebugPrintf("\nOrignal Rules source:\n");
     for (int32_t c=0; fRuleSource[c] != 0; c++) {
@@ -418,28 +399,6 @@ ubrk_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outD
                             outBytes+tableStartOffset+topSize, status);
     }
 
-    // Safe Forward state table.  Same layout as forward table, above.
-    tableStartOffset = ds->readUInt32(rbbiDH->fSFTable);
-    tableLength      = ds->readUInt32(rbbiDH->fSFTableLen);
-
-    if (tableLength > 0) {
-        ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
-                            outBytes+tableStartOffset, status);
-        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
-                            outBytes+tableStartOffset+topSize, status);
-    }
-
-    // Safe Reverse state table.  Same layout as forward table, above.
-    tableStartOffset = ds->readUInt32(rbbiDH->fSRTable);
-    tableLength      = ds->readUInt32(rbbiDH->fSRTableLen);
-
-    if (tableLength > 0) {
-        ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
-                            outBytes+tableStartOffset, status);
-        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
-                            outBytes+tableStartOffset+topSize, status);
-    }
-
     // Trie table for character categories
     utrie2_swap(ds, inBytes+ds->readUInt32(rbbiDH->fTrie), ds->readUInt32(rbbiDH->fTrieLen),
                     outBytes+ds->readUInt32(rbbiDH->fTrie), status);
diff --git a/deps/icu-small/source/common/rbbidata.h b/deps/icu-small/source/common/rbbidata.h
index 8b21acca304d5f..3e573039d0f491 100644
--- a/deps/icu-small/source/common/rbbidata.h
+++ b/deps/icu-small/source/common/rbbidata.h
@@ -58,7 +58,7 @@ ubrk_swap(const UDataSwapper *ds,
 U_NAMESPACE_BEGIN
 
 // The current RBBI data format version.
-static const uint8_t RBBI_DATA_FORMAT_VERSION[] = {4, 0, 0, 0};
+static const uint8_t RBBI_DATA_FORMAT_VERSION[] = {5, 0, 0, 0};
 
 /*
  *   The following structs map exactly onto the raw data from ICU common data file.
@@ -81,10 +81,6 @@ struct RBBIDataHeader {
     uint32_t         fFTableLen;
     uint32_t         fRTable;         /*  Offset to the reverse state transition table. */
     uint32_t         fRTableLen;
-    uint32_t         fSFTable;        /*  safe point forward transition table */
-    uint32_t         fSFTableLen;
-    uint32_t         fSRTable;        /*  safe point reverse transition table */
-    uint32_t         fSRTableLen;
     uint32_t         fTrie;           /*  Offset to Trie data for character categories */
     uint32_t         fTrieLen;
     uint32_t         fRuleSource;     /*  Offset to the source for for the break */
@@ -174,8 +170,6 @@ class RBBIDataWrapper : public UMemory {
     const RBBIDataHeader     *fHeader;
     const RBBIStateTable     *fForwardTable;
     const RBBIStateTable     *fReverseTable;
-    const RBBIStateTable     *fSafeFwdTable;
-    const RBBIStateTable     *fSafeRevTable;
     const UChar              *fRuleSource;
     const int32_t            *fRuleStatusTable;
 
diff --git a/deps/icu-small/source/common/rbbirb.cpp b/deps/icu-small/source/common/rbbirb.cpp
index 9fc8f8e814200a..a46f483d23334a 100644
--- a/deps/icu-small/source/common/rbbirb.cpp
+++ b/deps/icu-small/source/common/rbbirb.cpp
@@ -62,10 +62,7 @@ RBBIRuleBuilder::RBBIRuleBuilder(const UnicodeString   &rules,
     fSafeFwdTree        = NULL;
     fSafeRevTree        = NULL;
     fDefaultTree        = &fForwardTree;
-    fForwardTables      = NULL;
-    fReverseTables      = NULL;
-    fSafeFwdTables      = NULL;
-    fSafeRevTables      = NULL;
+    fForwardTable       = NULL;
     fRuleStatusVals     = NULL;
     fChainRules         = FALSE;
     fLBCMNoChain        = FALSE;
@@ -114,11 +111,7 @@ RBBIRuleBuilder::~RBBIRuleBuilder() {
 
     delete fUSetNodes;
     delete fSetBuilder;
-    delete fForwardTables;
-    delete fReverseTables;
-    delete fSafeFwdTables;
-    delete fSafeRevTables;
-
+    delete fForwardTable;
     delete fForwardTree;
     delete fReverseTree;
     delete fSafeFwdTree;
@@ -157,21 +150,15 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
     //     without the padding.
     //
     int32_t headerSize        = align8(sizeof(RBBIDataHeader));
-    int32_t forwardTableSize  = align8(fForwardTables->getTableSize());
-    int32_t reverseTableSize  = align8(fReverseTables->getTableSize());
-    int32_t safeFwdTableSize  = align8(fSafeFwdTables->getTableSize());
-    int32_t safeRevTableSize  = align8(fSafeRevTables->getTableSize());
+    int32_t forwardTableSize  = align8(fForwardTable->getTableSize());
+    int32_t reverseTableSize  = align8(fForwardTable->getSafeTableSize());
     int32_t trieSize          = align8(fSetBuilder->getTrieSize());
     int32_t statusTableSize   = align8(fRuleStatusVals->size() * sizeof(int32_t));
     int32_t rulesSize         = align8((fStrippedRules.length()+1) * sizeof(UChar));
 
-    (void)safeFwdTableSize;
-
     int32_t         totalSize = headerSize
                                 + forwardTableSize
-                                + /* reverseTableSize */ 0
-                                + /* safeFwdTableSize */ 0
-                                + (safeRevTableSize ? safeRevTableSize : reverseTableSize)
+                                + reverseTableSize
                                 + statusTableSize + trieSize + rulesSize;
 
     RBBIDataHeader  *data     = (RBBIDataHeader *)uprv_malloc(totalSize);
@@ -190,38 +177,13 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
     data->fLength           = totalSize;
     data->fCatCount         = fSetBuilder->getNumCharCategories();
 
-    // Only save the forward table and the safe reverse table,
-    // because these are the only ones used at run-time.
-    //
-    // For the moment, we still build the other tables if they are present in the rule source files,
-    // for backwards compatibility. Old rule files need to work, and this is the simplest approach.
-    //
-    // Additional backwards compatibility consideration: if no safe rules are provided, consider the
-    // reverse rules to actually be the safe reverse rules.
-
     data->fFTable        = headerSize;
     data->fFTableLen     = forwardTableSize;
 
-    // Do not save Reverse Table.
-    data->fRTable        = data->fFTable  + forwardTableSize;
-    data->fRTableLen     = 0;
-
-    // Do not save the Safe Forward table.
-    data->fSFTable       = data->fRTable + 0;
-    data->fSFTableLen    = 0;
-
-    data->fSRTable       = data->fSFTable + 0;
-    if (safeRevTableSize > 0) {
-        data->fSRTableLen    = safeRevTableSize;
-    } else if (reverseTableSize > 0) {
-        data->fSRTableLen    = reverseTableSize;
-    } else {
-        U_ASSERT(FALSE);    // Rule build should have failed for lack of a reverse table
-                            // before reaching this point.
-    }
-
+    data->fRTable        = data->fFTable  + data->fFTableLen;
+    data->fRTableLen     = reverseTableSize;
 
-    data->fTrie          = data->fSRTable + data->fSRTableLen;
+    data->fTrie          = data->fRTable + data->fRTableLen;
     data->fTrieLen       = fSetBuilder->getTrieSize();
     data->fStatusTable   = data->fTrie    + trieSize;
     data->fStatusTableLen= statusTableSize;
@@ -230,15 +192,8 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
 
     uprv_memset(data->fReserved, 0, sizeof(data->fReserved));
 
-    fForwardTables->exportTable((uint8_t *)data + data->fFTable);
-    // fReverseTables->exportTable((uint8_t *)data + data->fRTable);
-    // fSafeFwdTables->exportTable((uint8_t *)data + data->fSFTable);
-    if (safeRevTableSize > 0) {
-        fSafeRevTables->exportTable((uint8_t *)data + data->fSRTable);
-    } else {
-        fReverseTables->exportTable((uint8_t *)data + data->fSRTable);
-    }
-
+    fForwardTable->exportTable((uint8_t *)data + data->fFTable);
+    fForwardTable->exportSafeTable((uint8_t *)data + data->fRTable);
     fSetBuilder->serializeTrie ((uint8_t *)data + data->fTrie);
 
     int32_t *ruleStatusTable = (int32_t *)((uint8_t *)data + data->fStatusTable);
@@ -252,10 +207,6 @@ RBBIDataHeader *RBBIRuleBuilder::flattenData() {
 }
 
 
-
-
-
-
 //----------------------------------------------------------------------------------------
 //
 //  createRuleBasedBreakIterator    construct from source rules that are passed in
@@ -267,8 +218,6 @@ RBBIRuleBuilder::createRuleBasedBreakIterator( const UnicodeString    &rules,
                                     UParseError      *parseError,
                                     UErrorCode       &status)
 {
-    // status checked below
-
     //
     // Read the input rules, generate a parse tree, symbol table,
     // and list of all Unicode Sets referenced by the rules.
@@ -277,7 +226,38 @@ RBBIRuleBuilder::createRuleBasedBreakIterator( const UnicodeString    &rules,
     if (U_FAILURE(status)) { // status checked here bcos build below doesn't
         return NULL;
     }
-    builder.fScanner->parse();
+
+    RBBIDataHeader *data = builder.build(status);
+
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+
+    //
+    //  Create a break iterator from the compiled rules.
+    //     (Identical to creation from stored pre-compiled rules)
+    //
+    // status is checked after init in construction.
+    RuleBasedBreakIterator *This = new RuleBasedBreakIterator(data, status);
+    if (U_FAILURE(status)) {
+        delete This;
+        This = NULL;
+    }
+    else if(This == NULL) { // test for NULL
+        status = U_MEMORY_ALLOCATION_ERROR;
+    }
+    return This;
+}
+
+RBBIDataHeader *RBBIRuleBuilder::build(UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+
+    fScanner->parse();
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
 
     //
     // UnicodeSet processing.
@@ -285,95 +265,55 @@ RBBIRuleBuilder::createRuleBasedBreakIterator( const UnicodeString    &rules,
     //    Generate the mapping tables (TRIE) from input code points to
     //    the character categories.
     //
-    builder.fSetBuilder->buildRanges();
-
+    fSetBuilder->buildRanges();
 
     //
     //   Generate the DFA state transition table.
     //
-    builder.fForwardTables = new RBBITableBuilder(&builder, &builder.fForwardTree);
-    builder.fReverseTables = new RBBITableBuilder(&builder, &builder.fReverseTree);
-    builder.fSafeFwdTables = new RBBITableBuilder(&builder, &builder.fSafeFwdTree);
-    builder.fSafeRevTables = new RBBITableBuilder(&builder, &builder.fSafeRevTree);
-    if (builder.fForwardTables == NULL || builder.fReverseTables == NULL ||
-        builder.fSafeFwdTables == NULL || builder.fSafeRevTables == NULL)
-    {
+    fForwardTable = new RBBITableBuilder(this, &fForwardTree, status);
+    if (fForwardTable == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
-        delete builder.fForwardTables; builder.fForwardTables = NULL;
-        delete builder.fReverseTables; builder.fReverseTables = NULL;
-        delete builder.fSafeFwdTables; builder.fSafeFwdTables = NULL;
-        delete builder.fSafeRevTables; builder.fSafeRevTables = NULL;
-        return NULL;
+        return nullptr;
     }
 
-    builder.fForwardTables->build();
-    builder.fReverseTables->build();
-    builder.fSafeFwdTables->build();
-    builder.fSafeRevTables->build();
+    fForwardTable->buildForwardTable();
+    optimizeTables();
+    fForwardTable->buildSafeReverseTable(status);
+
 
 #ifdef RBBI_DEBUG
-    if (builder.fDebugEnv && uprv_strstr(builder.fDebugEnv, "states")) {
-        builder.fForwardTables->printRuleStatusTable();
+    if (fDebugEnv && uprv_strstr(fDebugEnv, "states")) {
+        fForwardTable->printStates();
+        fForwardTable->printRuleStatusTable();
+        fForwardTable->printReverseTable();
     }
 #endif
 
-    builder.optimizeTables();
-    builder.fSetBuilder->buildTrie();
-
-
+    fSetBuilder->buildTrie();
 
     //
     //   Package up the compiled data into a memory image
     //      in the run-time format.
     //
-    RBBIDataHeader *data = builder.flattenData(); // returns NULL if error
-    if (U_FAILURE(*builder.fStatus)) {
-        return NULL;
-    }
-
-
-    //
-    //  Clean up the compiler related stuff
-    //
-
-
-    //
-    //  Create a break iterator from the compiled rules.
-    //     (Identical to creation from stored pre-compiled rules)
-    //
-    // status is checked after init in construction.
-    RuleBasedBreakIterator *This = new RuleBasedBreakIterator(data, status);
+    RBBIDataHeader *data = flattenData(); // returns NULL if error
     if (U_FAILURE(status)) {
-        delete This;
-        This = NULL;
+        return nullptr;
     }
-    else if(This == NULL) { // test for NULL
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return This;
+    return data;
 }
 
 void RBBIRuleBuilder::optimizeTables() {
-    int32_t leftClass;
-    int32_t rightClass;
-
-    leftClass = 3;
-    rightClass = 0;
-    while (fForwardTables->findDuplCharClassFrom(leftClass, rightClass)) {
-        fSetBuilder->mergeCategories(leftClass, rightClass);
-        fForwardTables->removeColumn(rightClass);
-        fReverseTables->removeColumn(rightClass);
-        fSafeFwdTables->removeColumn(rightClass);
-        fSafeRevTables->removeColumn(rightClass);
-    }
-
-    fForwardTables->removeDuplicateStates();
-    fReverseTables->removeDuplicateStates();
-    fSafeFwdTables->removeDuplicateStates();
-    fSafeRevTables->removeDuplicateStates();
-
 
+    // Begin looking for duplicates with char class 3.
+    // Classes 0, 1 and 2 are special; they are unused, {bof} and {eof} respectively,
+    // and should not have other categories merged into them.
+    IntPair duplPair = {3, 0};
 
+    while (fForwardTable->findDuplCharClassFrom(&duplPair)) {
+        fSetBuilder->mergeCategories(duplPair);
+        fForwardTable->removeColumn(duplPair.second);
+    }
+    fForwardTable->removeDuplicateStates();
 }
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/common/rbbirb.h b/deps/icu-small/source/common/rbbirb.h
index 511f394b458e93..37992daabb0b14 100644
--- a/deps/icu-small/source/common/rbbirb.h
+++ b/deps/icu-small/source/common/rbbirb.h
@@ -18,6 +18,8 @@
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
+#include <utility>
+
 #include "unicode/uobject.h"
 #include "unicode/rbbi.h"
 #include "unicode/uniset.h"
@@ -25,8 +27,7 @@
 #include "uhash.h"
 #include "uvector.h"
 #include "unicode/symtable.h"// For UnicodeSet parsing, is the interface that
-                          //    looks up references to $variables within a set.
-
+                             //    looks up references to $variables within a set.
 
 
 U_NAMESPACE_BEGIN
@@ -123,10 +124,16 @@ class RBBIRuleBuilder : public UMemory {
     RBBIRuleBuilder(const UnicodeString  &rules,
                     UParseError          *parseErr,
                     UErrorCode           &status
-        );
+    );
 
     virtual    ~RBBIRuleBuilder();
 
+    /**
+     *  Build the state tables and char class Trie from the source rules.
+     */
+    RBBIDataHeader  *build(UErrorCode &status);
+
+
     /**
      * Fold together redundant character classes (table columns) and
      * redundant states (table rows). Done after initial table generation,
@@ -162,10 +169,7 @@ class RBBIRuleBuilder : public UMemory {
     RBBISetBuilder                *fSetBuilder;      // Set and Character Category builder.
     UVector                       *fUSetNodes;       // Vector of all uset nodes.
 
-    RBBITableBuilder              *fForwardTables;   // State transition tables
-    RBBITableBuilder              *fReverseTables;
-    RBBITableBuilder              *fSafeFwdTables;
-    RBBITableBuilder              *fSafeRevTables;
+    RBBITableBuilder              *fForwardTable;    // State transition table, build time form.
 
     UVector                       *fRuleStatusVals;  // The values that can be returned
                                                      //   from getRuleStatus().
@@ -200,6 +204,11 @@ struct RBBISetTableEl {
     RBBINode      *val;
 };
 
+/**
+ *   A pair of ints, used to bundle pairs of states or pairs of character classes.
+ */
+typedef std::pair<int32_t, int32_t> IntPair;
+
 
 //----------------------------------------------------------------------------
 //
diff --git a/deps/icu-small/source/common/rbbiscan.cpp b/deps/icu-small/source/common/rbbiscan.cpp
index e3472ed599e15e..ecc1663d8f84f7 100644
--- a/deps/icu-small/source/common/rbbiscan.cpp
+++ b/deps/icu-small/source/common/rbbiscan.cpp
@@ -372,7 +372,7 @@ UBool RBBIRuleScanner::doParseActions(int32_t action)
         //  (forward, reverse, safe_forward, safe_reverse)
         //  OR this rule into the appropriate group of them.
         //
-        RBBINode **destRules = (fReverseRule? &fRB->fReverseTree : fRB->fDefaultTree);
+        RBBINode **destRules = (fReverseRule? &fRB->fSafeRevTree : fRB->fDefaultTree);
 
         if (*destRules != NULL) {
             // This is not the first rule encounted.
@@ -1122,22 +1122,6 @@ void RBBIRuleScanner::parse() {
         return;
     }
 
-    //
-    // If there were NO user specified reverse rules, set up the equivalent of ".*;"
-    //
-    if (fRB->fReverseTree == NULL) {
-        fRB->fReverseTree  = pushNewNode(RBBINode::opStar);
-        RBBINode  *operand = pushNewNode(RBBINode::setRef);
-        if (U_FAILURE(*fRB->fStatus)) {
-            return;
-        }
-        findSetFor(UnicodeString(TRUE, kAny, 3), operand);
-        fRB->fReverseTree->fLeftChild = operand;
-        operand->fParent              = fRB->fReverseTree;
-        fNodeStackPtr -= 2;
-    }
-
-
     //
     // Parsing of the input RBBI rules is complete.
     // We now have a parse tree for the rule expressions
diff --git a/deps/icu-small/source/common/rbbisetb.cpp b/deps/icu-small/source/common/rbbisetb.cpp
index 4e7389b4af039b..e6b98cf3e22b98 100644
--- a/deps/icu-small/source/common/rbbisetb.cpp
+++ b/deps/icu-small/source/common/rbbisetb.cpp
@@ -270,15 +270,15 @@ void RBBISetBuilder::buildTrie() {
 }
 
 
-void RBBISetBuilder::mergeCategories(int32_t left, int32_t right) {
-    U_ASSERT(left >= 1);
-    U_ASSERT(right > left);
+void RBBISetBuilder::mergeCategories(IntPair categories) {
+    U_ASSERT(categories.first >= 1);
+    U_ASSERT(categories.second > categories.first);
     for (RangeDescriptor *rd = fRangeList; rd != nullptr; rd = rd->fNext) {
         int32_t rangeNum = rd->fNum & ~DICT_BIT;
         int32_t rangeDict = rd->fNum & DICT_BIT;
-        if (rangeNum == right) {
-            rd->fNum = left | rangeDict;
-        } else if (rangeNum > right) {
+        if (rangeNum == categories.second) {
+            rd->fNum = categories.first | rangeDict;
+        } else if (rangeNum > categories.second) {
             rd->fNum--;
         }
     }
diff --git a/deps/icu-small/source/common/rbbisetb.h b/deps/icu-small/source/common/rbbisetb.h
index a7a91b3b375b75..ed6a76b1214621 100644
--- a/deps/icu-small/source/common/rbbisetb.h
+++ b/deps/icu-small/source/common/rbbisetb.h
@@ -94,10 +94,12 @@ class RBBISetBuilder : public UMemory {
     UChar32  getFirstChar(int32_t  val) const;
     UBool    sawBOF() const;                 // Indicate whether any references to the {bof} pseudo
                                              //   character were encountered.
-    /** merge two character categories that have been identified as having equivalent behavior.
-     *  The ranges belonging to the right category (table column) will be added to the left.
+    /**
+     * Merge two character categories that have been identified as having equivalent behavior.
+     * The ranges belonging to the second category (table column) will be added to the first.
+     * @param categories the pair of categories to be merged.
      */
-    void     mergeCategories(int32_t left, int32_t right);
+    void     mergeCategories(IntPair categories);
 
     static constexpr int32_t DICT_BIT = 0x4000;
 
diff --git a/deps/icu-small/source/common/rbbitblb.cpp b/deps/icu-small/source/common/rbbitblb.cpp
index 61661a544249e2..42116b0f95575f 100644
--- a/deps/icu-small/source/common/rbbitblb.cpp
+++ b/deps/icu-small/source/common/rbbitblb.cpp
@@ -27,21 +27,19 @@
 
 U_NAMESPACE_BEGIN
 
-RBBITableBuilder::RBBITableBuilder(RBBIRuleBuilder *rb, RBBINode **rootNode) :
- fTree(*rootNode) {
-    fRB                 = rb;
-    fStatus             = fRB->fStatus;
-    UErrorCode status   = U_ZERO_ERROR;
-    fDStates            = new UVector(status);
-    if (U_FAILURE(*fStatus)) {
-        return;
-    }
+RBBITableBuilder::RBBITableBuilder(RBBIRuleBuilder *rb, RBBINode **rootNode, UErrorCode &status) :
+        fRB(rb),
+        fTree(*rootNode),
+        fStatus(&status),
+        fDStates(nullptr),
+        fSafeTable(nullptr) {
     if (U_FAILURE(status)) {
-        *fStatus = status;
         return;
     }
-    if (fDStates == NULL) {
-        *fStatus = U_MEMORY_ALLOCATION_ERROR;;
+    // fDStates is UVector<RBBIStateDescriptor *>
+    fDStates = new UVector(status);
+    if (U_SUCCESS(status) && fDStates == nullptr ) {
+        status = U_MEMORY_ALLOCATION_ERROR;
     }
 }
 
@@ -52,17 +50,18 @@ RBBITableBuilder::~RBBITableBuilder() {
     for (i=0; i<fDStates->size(); i++) {
         delete (RBBIStateDescriptor *)fDStates->elementAt(i);
     }
-    delete   fDStates;
+    delete fDStates;
+    delete fSafeTable;
 }
 
 
 //-----------------------------------------------------------------------------
 //
-//   RBBITableBuilder::build  -  This is the main function for building the DFA state transtion
-//                               table from the RBBI rules parse tree.
+//   RBBITableBuilder::buildForwardTable  -  This is the main function for building
+//                               the DFA state transition table from the RBBI rules parse tree.
 //
 //-----------------------------------------------------------------------------
-void  RBBITableBuilder::build() {
+void  RBBITableBuilder::buildForwardTable() {
 
     if (U_FAILURE(*fStatus)) {
         return;
@@ -189,8 +188,6 @@ void  RBBITableBuilder::build() {
     //    for all tables.  Merge the ones from this table into the global set.
     //
     mergeRuleStatusVals();
-
-    if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "states")) {printStates();};
 }
 
 
@@ -1081,18 +1078,18 @@ void RBBITableBuilder::printPosSets(RBBINode *n) {
 //
 //    findDuplCharClassFrom()
 //
-bool RBBITableBuilder::findDuplCharClassFrom(int32_t &baseCategory, int32_t &duplCategory) {
+bool RBBITableBuilder::findDuplCharClassFrom(IntPair *categories) {
     int32_t numStates = fDStates->size();
     int32_t numCols = fRB->fSetBuilder->getNumCharCategories();
 
     uint16_t table_base;
     uint16_t table_dupl;
-    for (; baseCategory < numCols-1; ++baseCategory) {
-        for (duplCategory=baseCategory+1; duplCategory < numCols; ++duplCategory) {
+    for (; categories->first < numCols-1; categories->first++) {
+        for (categories->second=categories->first+1; categories->second < numCols; categories->second++) {
              for (int32_t state=0; state<numStates; state++) {
                  RBBIStateDescriptor *sd = (RBBIStateDescriptor *)fDStates->elementAt(state);
-                 table_base = (uint16_t)sd->fDtran->elementAti(baseCategory);
-                 table_dupl = (uint16_t)sd->fDtran->elementAti(duplCategory);
+                 table_base = (uint16_t)sd->fDtran->elementAti(categories->first);
+                 table_dupl = (uint16_t)sd->fDtran->elementAti(categories->second);
                  if (table_base != table_dupl) {
                      break;
                  }
@@ -1121,14 +1118,14 @@ void RBBITableBuilder::removeColumn(int32_t column) {
 /*
  * findDuplicateState
  */
-bool RBBITableBuilder::findDuplicateState(int32_t &firstState, int32_t &duplState) {
+bool RBBITableBuilder::findDuplicateState(IntPair *states) {
     int32_t numStates = fDStates->size();
     int32_t numCols = fRB->fSetBuilder->getNumCharCategories();
 
-    for (; firstState<numStates-1; ++firstState) {
-        RBBIStateDescriptor *firstSD = (RBBIStateDescriptor *)fDStates->elementAt(firstState);
-        for (duplState=firstState+1; duplState<numStates; ++duplState) {
-            RBBIStateDescriptor *duplSD = (RBBIStateDescriptor *)fDStates->elementAt(duplState);
+    for (; states->first<numStates-1; states->first++) {
+        RBBIStateDescriptor *firstSD = (RBBIStateDescriptor *)fDStates->elementAt(states->first);
+        for (states->second=states->first+1; states->second<numStates; states->second++) {
+            RBBIStateDescriptor *duplSD = (RBBIStateDescriptor *)fDStates->elementAt(states->second);
             if (firstSD->fAccepting != duplSD->fAccepting ||
                 firstSD->fLookAhead != duplSD->fLookAhead ||
                 firstSD->fTagsIdx   != duplSD->fTagsIdx) {
@@ -1139,8 +1136,36 @@ bool RBBITableBuilder::findDuplicateState(int32_t &firstState, int32_t &duplStat
                 int32_t firstVal = firstSD->fDtran->elementAti(col);
                 int32_t duplVal = duplSD->fDtran->elementAti(col);
                 if (!((firstVal == duplVal) ||
-                        ((firstVal == firstState || firstVal == duplState) &&
-                        (duplVal  == firstState || duplVal  == duplState)))) {
+                        ((firstVal == states->first || firstVal == states->second) &&
+                        (duplVal  == states->first || duplVal  == states->second)))) {
+                    rowsMatch = false;
+                    break;
+                }
+            }
+            if (rowsMatch) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+
+bool RBBITableBuilder::findDuplicateSafeState(IntPair *states) {
+    int32_t numStates = fSafeTable->size();
+
+    for (; states->first<numStates-1; states->first++) {
+        UnicodeString *firstRow = static_cast<UnicodeString *>(fSafeTable->elementAt(states->first));
+        for (states->second=states->first+1; states->second<numStates; states->second++) {
+            UnicodeString *duplRow = static_cast<UnicodeString *>(fSafeTable->elementAt(states->second));
+            bool rowsMatch = true;
+            int32_t numCols = firstRow->length();
+            for (int32_t col=0; col < numCols; ++col) {
+                int32_t firstVal = firstRow->charAt(col);
+                int32_t duplVal = duplRow->charAt(col);
+                if (!((firstVal == duplVal) ||
+                        ((firstVal == states->first || firstVal == states->second) &&
+                        (duplVal  == states->first || duplVal  == states->second)))) {
                     rowsMatch = false;
                     break;
                 }
@@ -1153,7 +1178,10 @@ bool RBBITableBuilder::findDuplicateState(int32_t &firstState, int32_t &duplStat
     return false;
 }
 
-void RBBITableBuilder::removeState(int32_t keepState, int32_t duplState) {
+
+void RBBITableBuilder::removeState(IntPair duplStates) {
+    const int32_t keepState = duplStates.first;
+    const int32_t duplState = duplStates.second;
     U_ASSERT(keepState < duplState);
     U_ASSERT(duplState < fDStates->size());
 
@@ -1188,19 +1216,44 @@ void RBBITableBuilder::removeState(int32_t keepState, int32_t duplState) {
     }
 }
 
+void RBBITableBuilder::removeSafeState(IntPair duplStates) {
+    const int32_t keepState = duplStates.first;
+    const int32_t duplState = duplStates.second;
+    U_ASSERT(keepState < duplState);
+    U_ASSERT(duplState < fSafeTable->size());
+
+    fSafeTable->removeElementAt(duplState);   // Note that fSafeTable has a deleter function
+                                              // and will auto-delete the removed element.
+    int32_t numStates = fSafeTable->size();
+    for (int32_t state=0; state<numStates; ++state) {
+        UnicodeString *sd = (UnicodeString *)fSafeTable->elementAt(state);
+        int32_t numCols = sd->length();
+        for (int32_t col=0; col<numCols; col++) {
+            int32_t existingVal = sd->charAt(col);
+            int32_t newVal = existingVal;
+            if (existingVal == duplState) {
+                newVal = keepState;
+            } else if (existingVal > duplState) {
+                newVal = existingVal - 1;
+            }
+            sd->setCharAt(col, newVal);
+        }
+    }
+}
+
 
 /*
  * RemoveDuplicateStates
  */
 void RBBITableBuilder::removeDuplicateStates() {
-    int32_t firstState = 3;
-    int32_t duplicateState = 0;
-    while (findDuplicateState(firstState, duplicateState)) {
-        // printf("Removing duplicate states (%d, %d)\n", firstState, duplicateState);
-        removeState(firstState, duplicateState);
+    IntPair dupls = {3, 0};
+    while (findDuplicateState(&dupls)) {
+        // printf("Removing duplicate states (%d, %d)\n", dupls.first, dupls.second);
+        removeState(dupls);
     }
 }
 
+
 //-----------------------------------------------------------------------------
 //
 //   getTableSize()    Calculate the size of the runtime form of this
@@ -1277,6 +1330,185 @@ void RBBITableBuilder::exportTable(void *where) {
 }
 
 
+/**
+ *   Synthesize a safe state table from the main state table.
+ */
+void RBBITableBuilder::buildSafeReverseTable(UErrorCode &status) {
+    // The safe table creation has three steps:
+
+    // 1. Identifiy pairs of character classes that are "safe." Safe means that boundaries
+    // following the pair do not depend on context or state before the pair. To test
+    // whether a pair is safe, run it through the main forward state table, starting
+    // from each state. If the the final state is the same, no matter what the starting state,
+    // the pair is safe.
+    //
+    // 2. Build a state table that recognizes the safe pairs. It's similar to their
+    // forward table, with a column for each input character [class], and a row for
+    // each state. Row 1 is the start state, and row 0 is the stop state. Initially
+    // create an additional state for each input character category; being in
+    // one of these states means that the character has been seen, and is potentially
+    // the first of a pair. In each of these rows, the entry for the second character
+    // of a safe pair is set to the stop state (0), indicating that a match was found.
+    // All other table entries are set to the state corresponding the current input
+    // character, allowing that charcter to be the of a start following pair.
+    //
+    // Because the safe rules are to be run in reverse, moving backwards in the text,
+    // the first and second pair categories are swapped when building the table.
+    //
+    // 3. Compress the table. There are typically many rows (states) that are
+    // equivalent - that have zeroes (match completed) in the same columns -
+    // and can be folded together.
+
+    // Each safe pair is stored as two UChars in the safePair string.
+    UnicodeString safePairs;
+
+    int32_t numCharClasses = fRB->fSetBuilder->getNumCharCategories();
+    int32_t numStates = fDStates->size();
+
+    for (int32_t c1=0; c1<numCharClasses; ++c1) {
+        for (int32_t c2=0; c2 < numCharClasses; ++c2) {
+            int32_t wantedEndState = -1;
+            int32_t endState = 0;
+            for (int32_t startState = 1; startState < numStates; ++startState) {
+                RBBIStateDescriptor *startStateD = static_cast<RBBIStateDescriptor *>(fDStates->elementAt(startState));
+                int32_t s2 = startStateD->fDtran->elementAti(c1);
+                RBBIStateDescriptor *s2StateD = static_cast<RBBIStateDescriptor *>(fDStates->elementAt(s2));
+                endState = s2StateD->fDtran->elementAti(c2);
+                if (wantedEndState < 0) {
+                    wantedEndState = endState;
+                } else {
+                    if (wantedEndState != endState) {
+                        break;
+                    }
+                }
+            }
+            if (wantedEndState == endState) {
+                safePairs.append((char16_t)c1);
+                safePairs.append((char16_t)c2);
+                // printf("(%d, %d) ", c1, c2);
+            }
+        }
+        // printf("\n");
+    }
+
+    // Populate the initial safe table.
+    // The table as a whole is UVector<UnicodeString>
+    // Each row is represented by a UnicodeString, being used as a Vector<int16>.
+    // Row 0 is the stop state.
+    // Row 1 is the start sate.
+    // Row 2 and beyond are other states, initially one per char class, but
+    //   after initial construction, many of the states will be combined, compacting the table.
+    // The String holds the nextState data only. The four leading fields of a row, fAccepting,
+    // fLookAhead, etc. are not needed for the safe table, and are omitted at this stage of building.
+
+    U_ASSERT(fSafeTable == nullptr);
+    fSafeTable = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, numCharClasses + 2, status);
+    for (int32_t row=0; row<numCharClasses + 2; ++row) {
+        fSafeTable->addElement(new UnicodeString(numCharClasses, 0, numCharClasses+4), status);
+    }
+
+    // From the start state, each input char class transitions to the state for that input.
+    UnicodeString &startState = *static_cast<UnicodeString *>(fSafeTable->elementAt(1));
+    for (int32_t charClass=0; charClass < numCharClasses; ++charClass) {
+        // Note: +2 for the start & stop state.
+        startState.setCharAt(charClass, charClass+2);
+    }
+
+    // Initially make every other state table row look like the start state row,
+    for (int32_t row=2; row<numCharClasses+2; ++row) {
+        UnicodeString &rowState = *static_cast<UnicodeString *>(fSafeTable->elementAt(row));
+        rowState = startState;   // UnicodeString assignment, copies contents.
+    }
+
+    // Run through the safe pairs, set the next state to zero when pair has been seen.
+    // Zero being the stop state, meaning we found a safe point.
+    for (int32_t pairIdx=0; pairIdx<safePairs.length(); pairIdx+=2) {
+        int32_t c1 = safePairs.charAt(pairIdx);
+        int32_t c2 = safePairs.charAt(pairIdx + 1);
+
+        UnicodeString &rowState = *static_cast<UnicodeString *>(fSafeTable->elementAt(c2 + 2));
+        rowState.setCharAt(c1, 0);
+    }
+
+    // Remove duplicate or redundant rows from the table.
+    IntPair states = {1, 0};
+    while (findDuplicateSafeState(&states)) {
+        // printf("Removing duplicate safe states (%d, %d)\n", states.first, states.second);
+        removeSafeState(states);
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//   getSafeTableSize()    Calculate the size of the runtime form of this
+//                         safe state table.
+//
+//-----------------------------------------------------------------------------
+int32_t  RBBITableBuilder::getSafeTableSize() const {
+    int32_t    size = 0;
+    int32_t    numRows;
+    int32_t    numCols;
+    int32_t    rowSize;
+
+    if (fSafeTable == nullptr) {
+        return 0;
+    }
+
+    size    = offsetof(RBBIStateTable, fTableData);    // The header, with no rows to the table.
+
+    numRows = fSafeTable->size();
+    numCols = fRB->fSetBuilder->getNumCharCategories();
+
+    rowSize = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t)*numCols;
+    size   += numRows * rowSize;
+    return size;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//   exportSafeTable()   export the state transition table in the format required
+//                       by the runtime engine.  getTableSize() bytes of memory
+//                       must be available at the output address "where".
+//
+//-----------------------------------------------------------------------------
+void RBBITableBuilder::exportSafeTable(void *where) {
+    RBBIStateTable    *table = (RBBIStateTable *)where;
+    uint32_t           state;
+    int                col;
+
+    if (U_FAILURE(*fStatus) || fSafeTable == nullptr) {
+        return;
+    }
+
+    int32_t catCount = fRB->fSetBuilder->getNumCharCategories();
+    if (catCount > 0x7fff ||
+            fSafeTable->size() > 0x7fff) {
+        *fStatus = U_BRK_INTERNAL_ERROR;
+        return;
+    }
+
+    table->fRowLen    = offsetof(RBBIStateTableRow, fNextState) + sizeof(uint16_t) * catCount;
+    table->fNumStates = fSafeTable->size();
+    table->fFlags     = 0;
+    table->fReserved  = 0;
+
+    for (state=0; state<table->fNumStates; state++) {
+        UnicodeString *rowString = (UnicodeString *)fSafeTable->elementAt(state);
+        RBBIStateTableRow   *row = (RBBIStateTableRow *)(table->fTableData + state*table->fRowLen);
+        row->fAccepting = 0;
+        row->fLookAhead = 0;
+        row->fTagIdx    = 0;
+        row->fReserved  = 0;
+        for (col=0; col<catCount; col++) {
+            row->fNextState[col] = rowString->charAt(col);
+        }
+    }
+}
+
+
+
 
 //-----------------------------------------------------------------------------
 //
@@ -1331,6 +1563,47 @@ void RBBITableBuilder::printStates() {
 #endif
 
 
+//-----------------------------------------------------------------------------
+//
+//   printSafeTable    Debug Function.  Dump the fully constructed safe table.
+//
+//-----------------------------------------------------------------------------
+#ifdef RBBI_DEBUG
+void RBBITableBuilder::printReverseTable() {
+    int     c;    // input "character"
+    int     n;    // state number
+
+    RBBIDebugPrintf("    Safe Reverse Table \n");
+    if (fSafeTable == nullptr) {
+        RBBIDebugPrintf("   --- nullptr ---\n");
+        return;
+    }
+    RBBIDebugPrintf("state |           i n p u t     s y m b o l s \n");
+    RBBIDebugPrintf("      | Acc  LA    Tag");
+    for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
+        RBBIDebugPrintf(" %2d", c);
+    }
+    RBBIDebugPrintf("\n");
+    RBBIDebugPrintf("      |---------------");
+    for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
+        RBBIDebugPrintf("---");
+    }
+    RBBIDebugPrintf("\n");
+
+    for (n=0; n<fSafeTable->size(); n++) {
+        UnicodeString *rowString = (UnicodeString *)fSafeTable->elementAt(n);
+        RBBIDebugPrintf("  %3d | " , n);
+        RBBIDebugPrintf("%3d %3d %5d ", 0, 0, 0);  // Accepting, LookAhead, Tags
+        for (c=0; c<fRB->fSetBuilder->getNumCharCategories(); c++) {
+            RBBIDebugPrintf(" %2d", rowString->charAt(c));
+        }
+        RBBIDebugPrintf("\n");
+    }
+    RBBIDebugPrintf("\n\n");
+}
+#endif
+
+
 
 //-----------------------------------------------------------------------------
 //
diff --git a/deps/icu-small/source/common/rbbitblb.h b/deps/icu-small/source/common/rbbitblb.h
index 09b57b5cf0f4c3..eea243e4cdd6c3 100644
--- a/deps/icu-small/source/common/rbbitblb.h
+++ b/deps/icu-small/source/common/rbbitblb.h
@@ -17,6 +17,7 @@
 #include "unicode/utypes.h"
 #include "unicode/uobject.h"
 #include "unicode/rbbi.h"
+#include "rbbirb.h"
 #include "rbbinode.h"
 
 
@@ -37,22 +38,28 @@ class UVector32;
 
 class RBBITableBuilder : public UMemory {
 public:
-    RBBITableBuilder(RBBIRuleBuilder *rb, RBBINode **rootNode);
+    RBBITableBuilder(RBBIRuleBuilder *rb, RBBINode **rootNode, UErrorCode &status);
     ~RBBITableBuilder();
 
-    void     build();
-    int32_t  getTableSize() const;      // Return the runtime size in bytes of
-                                        //     the built state table
+    void     buildForwardTable();
+
+    /** Return the runtime size in bytes of the built state table.  */
+    int32_t  getTableSize() const;
 
     /** Fill in the runtime state table. Sufficient memory must exist at the specified location.
      */
     void     exportTable(void *where);
 
-    /** Find duplicate (redundant) character classes, beginning after the specifed
-     *  pair, within this state table. This is an iterator-like function, used to
-     *  identify char classes (state table columns) that can be eliminated.
+    /**
+     *  Find duplicate (redundant) character classes. Begin looking with categories.first.
+     *  Duplicate, if found are returned in the categories parameter.
+     *  This is an iterator-like function, used to identify character classes
+     *  (state table columns) that can be eliminated.
+     *  @param categories in/out parameter, specifies where to start looking for duplicates,
+     *                and returns the first pair of duplicates found, if any.
+     *  @return true if duplicate char classes were found, false otherwise.
      */
-    bool     findDuplCharClassFrom(int &baseClass, int &duplClass);
+    bool     findDuplCharClassFrom(IntPair *categories);
 
     /** Remove a column from the state table. Used when two character categories
      *  have been found equivalent, and merged together, to eliminate the uneeded table column.
@@ -62,6 +69,16 @@ class RBBITableBuilder : public UMemory {
     /** Check for, and remove dupicate states (table rows). */
     void     removeDuplicateStates();
 
+    /** Build the safe reverse table from the already-constructed forward table. */
+    void     buildSafeReverseTable(UErrorCode &status);
+
+    /** Return the runtime size in bytes of the built safe reverse state table. */
+    int32_t  getSafeTableSize() const;
+
+    /** Fill in the runtime safe state table. Sufficient memory must exist at the specified location.
+     */
+    void     exportSafeTable(void *where);
+
 
 private:
     void     calcNullable(RBBINode *n);
@@ -84,20 +101,36 @@ class RBBITableBuilder : public UMemory {
 
     void     addRuleRootNodes(UVector *dest, RBBINode *node);
 
-    /** Find the next duplicate state. An iterator function.
-     * @param firstState (in/out) begin looking at this state, return the first of the
-     *                   pair of duplicates.
-     * @param duplicateState returns the duplicate state of fistState
-     * @return true if a duplicate pair of states was found.
+    /**
+     *  Find duplicate (redundant) states, beginning at the specified pair,
+     *  within this state table. This is an iterator-like function, used to
+     *  identify states (state table rows) that can be eliminated.
+     *  @param states in/out parameter, specifies where to start looking for duplicates,
+     *                and returns the first pair of duplicates found, if any.
+     *  @return true if duplicate states were found, false otherwise.
+     */
+    bool findDuplicateState(IntPair *states);
+
+    /** Remove a duplicate state.
+     * @param duplStates The duplicate states. The first is kept, the second is removed.
+     *                   All references to the second in the state table are retargeted
+     *                   to the first.
      */
-    bool findDuplicateState(int32_t &firstState, int32_t &duplicateState);
+    void removeState(IntPair duplStates);
 
-    /** Remove a duplicate state/
-     * @param keepState First of the duplicate pair. Keep it.
-     * @param duplState Duplicate state. Remove it. Redirect all references to the duplicate state
-     *                  to refer to keepState instead.
+    /** Find the next duplicate state in the safe reverse table. An iterator function.
+     *  @param states in/out parameter, specifies where to start looking for duplicates,
+     *                and returns the first pair of duplicates found, if any.
+     *  @return true if a duplicate pair of states was found.
      */
-    void removeState(int32_t keepState, int32_t duplState);
+    bool findDuplicateSafeState(IntPair *states);
+
+    /** Remove a duplicate state from the safe table.
+     * @param duplStates The duplicate states. The first is kept, the second is removed.
+     *                   All references to the second in the state table are retargeted
+     *                   to the first.
+     */
+    void removeSafeState(IntPair duplStates);
 
     // Set functions for UVector.
     //   TODO:  make a USet subclass of UVector
@@ -113,11 +146,13 @@ class RBBITableBuilder : public UMemory {
     void     printPosSets(RBBINode *n /* = NULL*/);
     void     printStates();
     void     printRuleStatusTable();
+    void     printReverseTable();
 #else
     #define  printSet(s)
     #define  printPosSets(n)
     #define  printStates()
     #define  printRuleStatusTable()
+    #define  printReverseTable()
 #endif
 
 private:
@@ -126,10 +161,14 @@ class RBBITableBuilder : public UMemory {
                                            //   table for.
     UErrorCode       *fStatus;
 
+    /** State Descriptors, UVector<RBBIStateDescriptor> */
     UVector          *fDStates;            //  D states (Aho's terminology)
                                            //  Index is state number
                                            //  Contents are RBBIStateDescriptor pointers.
 
+    /** Synthesized safe table, UVector of UnicodeString, one string per table row.   */
+    UVector          *fSafeTable;
+
 
     RBBITableBuilder(const RBBITableBuilder &other); // forbid copying of this class
     RBBITableBuilder &operator=(const RBBITableBuilder &other); // forbid copying of this class
diff --git a/deps/icu-small/source/common/serv.cpp b/deps/icu-small/source/common/serv.cpp
index 8913b21e69457d..35e362b71a8fc2 100644
--- a/deps/icu-small/source/common/serv.cpp
+++ b/deps/icu-small/source/common/serv.cpp
@@ -547,16 +547,15 @@ ICUService::getKey(ICUServiceKey& key, UnicodeString* actualReturn, const ICUSer
             if (putInCache && cacheResult) {
                 serviceCache->put(result->actualDescriptor, result, status);
                 if (U_FAILURE(status)) {
-                    delete result;
                     return NULL;
                 }
 
                 if (cacheDescriptorList._obj != NULL) {
                     for (int32_t i = cacheDescriptorList._obj->size(); --i >= 0;) {
                         UnicodeString* desc = (UnicodeString*)cacheDescriptorList._obj->elementAt(i);
+
                         serviceCache->put(*desc, result, status);
                         if (U_FAILURE(status)) {
-                            delete result;
                             return NULL;
                         }
 
diff --git a/deps/icu-small/source/common/static_unicode_sets.cpp b/deps/icu-small/source/common/static_unicode_sets.cpp
new file mode 100644
index 00000000000000..9e731f5781e215
--- /dev/null
+++ b/deps/icu-small/source/common/static_unicode_sets.cpp
@@ -0,0 +1,222 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "static_unicode_sets.h"
+#include "umutex.h"
+#include "ucln_cmn.h"
+#include "unicode/uniset.h"
+#include "uresimp.h"
+#include "cstring.h"
+#include "uassert.h"
+
+using namespace icu;
+using namespace icu::unisets;
+
+
+namespace {
+
+UnicodeSet* gUnicodeSets[COUNT] = {};
+
+// Save the empty instance in static memory to have well-defined behavior if a
+// regular UnicodeSet cannot be allocated.
+char gEmptyUnicodeSet[sizeof(UnicodeSet)];
+
+// Whether the gEmptyUnicodeSet is initialized and ready to use.
+UBool gEmptyUnicodeSetInitialized = FALSE;
+
+inline UnicodeSet* getImpl(Key key) {
+    UnicodeSet* candidate = gUnicodeSets[key];
+    if (candidate == nullptr) {
+        return reinterpret_cast<UnicodeSet*>(gEmptyUnicodeSet);
+    }
+    return candidate;
+}
+
+UnicodeSet* computeUnion(Key k1, Key k2) {
+    UnicodeSet* result = new UnicodeSet();
+    if (result == nullptr) {
+        return nullptr;
+    }
+    result->addAll(*getImpl(k1));
+    result->addAll(*getImpl(k2));
+    result->freeze();
+    return result;
+}
+
+UnicodeSet* computeUnion(Key k1, Key k2, Key k3) {
+    UnicodeSet* result = new UnicodeSet();
+    if (result == nullptr) {
+        return nullptr;
+    }
+    result->addAll(*getImpl(k1));
+    result->addAll(*getImpl(k2));
+    result->addAll(*getImpl(k3));
+    result->freeze();
+    return result;
+}
+
+
+void saveSet(Key key, const UnicodeString& unicodeSetPattern, UErrorCode& status) {
+    // assert unicodeSets.get(key) == null;
+    gUnicodeSets[key] = new UnicodeSet(unicodeSetPattern, status);
+}
+
+class ParseDataSink : public ResourceSink {
+  public:
+    void put(const char* key, ResourceValue& value, UBool /*noFallback*/, UErrorCode& status) U_OVERRIDE {
+        ResourceTable contextsTable = value.getTable(status);
+        if (U_FAILURE(status)) { return; }
+        for (int i = 0; contextsTable.getKeyAndValue(i, key, value); i++) {
+            if (uprv_strcmp(key, "date") == 0) {
+                // ignore
+            } else {
+                ResourceTable strictnessTable = value.getTable(status);
+                if (U_FAILURE(status)) { return; }
+                for (int j = 0; strictnessTable.getKeyAndValue(j, key, value); j++) {
+                    bool isLenient = (uprv_strcmp(key, "lenient") == 0);
+                    ResourceArray array = value.getArray(status);
+                    if (U_FAILURE(status)) { return; }
+                    for (int k = 0; k < array.getSize(); k++) {
+                        array.getValue(k, value);
+                        UnicodeString str = value.getUnicodeString(status);
+                        if (U_FAILURE(status)) { return; }
+                        // There is both lenient and strict data for comma/period,
+                        // but not for any of the other symbols.
+                        if (str.indexOf(u'.') != -1) {
+                            saveSet(isLenient ? PERIOD : STRICT_PERIOD, str, status);
+                        } else if (str.indexOf(u',') != -1) {
+                            saveSet(isLenient ? COMMA : STRICT_COMMA, str, status);
+                        } else if (str.indexOf(u'+') != -1) {
+                            saveSet(PLUS_SIGN, str, status);
+                        } else if (str.indexOf(u'‒') != -1) {
+                            saveSet(MINUS_SIGN, str, status);
+                        } else if (str.indexOf(u'$') != -1) {
+                            saveSet(DOLLAR_SIGN, str, status);
+                        } else if (str.indexOf(u'£') != -1) {
+                            saveSet(POUND_SIGN, str, status);
+                        } else if (str.indexOf(u'₨') != -1) {
+                            saveSet(RUPEE_SIGN, str, status);
+                        }
+                        if (U_FAILURE(status)) { return; }
+                    }
+                }
+            }
+        }
+    }
+};
+
+
+icu::UInitOnce gNumberParseUniSetsInitOnce = U_INITONCE_INITIALIZER;
+
+UBool U_CALLCONV cleanupNumberParseUniSets() {
+    if (gEmptyUnicodeSetInitialized) {
+        reinterpret_cast<UnicodeSet*>(gEmptyUnicodeSet)->~UnicodeSet();
+        gEmptyUnicodeSetInitialized = FALSE;
+    }
+    for (int32_t i = 0; i < COUNT; i++) {
+        delete gUnicodeSets[i];
+        gUnicodeSets[i] = nullptr;
+    }
+    gNumberParseUniSetsInitOnce.reset();
+    return TRUE;
+}
+
+void U_CALLCONV initNumberParseUniSets(UErrorCode& status) {
+    ucln_common_registerCleanup(UCLN_COMMON_NUMPARSE_UNISETS, cleanupNumberParseUniSets);
+
+    // Initialize the empty instance for well-defined fallback behavior
+    new(gEmptyUnicodeSet) UnicodeSet();
+    reinterpret_cast<UnicodeSet*>(gEmptyUnicodeSet)->freeze();
+    gEmptyUnicodeSetInitialized = TRUE;
+
+    // These sets were decided after discussion with icu-design@. See tickets #13084 and #13309.
+    // Zs+TAB is "horizontal whitespace" according to UTS #18 (blank property).
+    gUnicodeSets[DEFAULT_IGNORABLES] = new UnicodeSet(
+            u"[[:Zs:][\\u0009][:Bidi_Control:][:Variation_Selector:]]", status);
+    gUnicodeSets[STRICT_IGNORABLES] = new UnicodeSet(u"[[:Bidi_Control:]]", status);
+
+    LocalUResourceBundlePointer rb(ures_open(nullptr, "root", &status));
+    if (U_FAILURE(status)) { return; }
+    ParseDataSink sink;
+    ures_getAllItemsWithFallback(rb.getAlias(), "parse", sink, status);
+    if (U_FAILURE(status)) { return; }
+
+    // NOTE: It is OK for these assertions to fail if there was a no-data build.
+    U_ASSERT(gUnicodeSets[COMMA] != nullptr);
+    U_ASSERT(gUnicodeSets[STRICT_COMMA] != nullptr);
+    U_ASSERT(gUnicodeSets[PERIOD] != nullptr);
+    U_ASSERT(gUnicodeSets[STRICT_PERIOD] != nullptr);
+
+    gUnicodeSets[OTHER_GROUPING_SEPARATORS] = new UnicodeSet(
+            u"['٬‘’＇\\u0020\\u00A0\\u2000-\\u200A\\u202F\\u205F\\u3000]", status);
+    gUnicodeSets[ALL_SEPARATORS] = computeUnion(COMMA, PERIOD, OTHER_GROUPING_SEPARATORS);
+    gUnicodeSets[STRICT_ALL_SEPARATORS] = computeUnion(
+            STRICT_COMMA, STRICT_PERIOD, OTHER_GROUPING_SEPARATORS);
+
+    U_ASSERT(gUnicodeSets[MINUS_SIGN] != nullptr);
+    U_ASSERT(gUnicodeSets[PLUS_SIGN] != nullptr);
+
+    gUnicodeSets[PERCENT_SIGN] = new UnicodeSet(u"[%٪]", status);
+    gUnicodeSets[PERMILLE_SIGN] = new UnicodeSet(u"[‰؉]", status);
+    gUnicodeSets[INFINITY_KEY] = new UnicodeSet(u"[∞]", status);
+
+    U_ASSERT(gUnicodeSets[DOLLAR_SIGN] != nullptr);
+    U_ASSERT(gUnicodeSets[POUND_SIGN] != nullptr);
+    U_ASSERT(gUnicodeSets[RUPEE_SIGN] != nullptr);
+    gUnicodeSets[YEN_SIGN] = new UnicodeSet(u"[¥\\uffe5]", status);
+
+    gUnicodeSets[DIGITS] = new UnicodeSet(u"[:digit:]", status);
+
+    gUnicodeSets[DIGITS_OR_ALL_SEPARATORS] = computeUnion(DIGITS, ALL_SEPARATORS);
+    gUnicodeSets[DIGITS_OR_STRICT_ALL_SEPARATORS] = computeUnion(DIGITS, STRICT_ALL_SEPARATORS);
+
+    for (auto* uniset : gUnicodeSets) {
+        if (uniset != nullptr) {
+            uniset->freeze();
+        }
+    }
+}
+
+}
+
+const UnicodeSet* unisets::get(Key key) {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    umtx_initOnce(gNumberParseUniSetsInitOnce, &initNumberParseUniSets, localStatus);
+    if (U_FAILURE(localStatus)) {
+        return reinterpret_cast<UnicodeSet*>(gEmptyUnicodeSet);
+    }
+    return getImpl(key);
+}
+
+Key unisets::chooseFrom(UnicodeString str, Key key1) {
+    return get(key1)->contains(str) ? key1 : NONE;
+}
+
+Key unisets::chooseFrom(UnicodeString str, Key key1, Key key2) {
+    return get(key1)->contains(str) ? key1 : chooseFrom(str, key2);
+}
+
+//Key unisets::chooseCurrency(UnicodeString str) {
+//    if (get(DOLLAR_SIGN)->contains(str)) {
+//        return DOLLAR_SIGN;
+//    } else if (get(POUND_SIGN)->contains(str)) {
+//        return POUND_SIGN;
+//    } else if (get(RUPEE_SIGN)->contains(str)) {
+//        return RUPEE_SIGN;
+//    } else if (get(YEN_SIGN)->contains(str)) {
+//        return YEN_SIGN;
+//    } else {
+//        return NONE;
+//    }
+//}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/common/static_unicode_sets.h b/deps/icu-small/source/common/static_unicode_sets.h
new file mode 100644
index 00000000000000..5f18b3217eae2b
--- /dev/null
+++ b/deps/icu-small/source/common/static_unicode_sets.h
@@ -0,0 +1,119 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+// This file is in common instead of i18n because it is needed by ucurr.cpp.
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __STATIC_UNICODE_SETS_H__
+#define __STATIC_UNICODE_SETS_H__
+
+#include "unicode/uniset.h"
+#include "unicode/unistr.h"
+
+U_NAMESPACE_BEGIN
+namespace unisets {
+
+enum Key {
+    // NONE is used to indicate null in chooseFrom().
+    // EMPTY is used to get an empty UnicodeSet.
+    NONE = -1,
+    EMPTY = 0,
+
+    // Ignorables
+    DEFAULT_IGNORABLES,
+    STRICT_IGNORABLES,
+
+    // Separators
+    // Notes:
+    // - COMMA is a superset of STRICT_COMMA
+    // - PERIOD is a superset of SCRICT_PERIOD
+    // - ALL_SEPARATORS is the union of COMMA, PERIOD, and OTHER_GROUPING_SEPARATORS
+    // - STRICT_ALL_SEPARATORS is the union of STRICT_COMMA, STRICT_PERIOD, and OTHER_GRP_SEPARATORS
+    COMMA,
+    PERIOD,
+    STRICT_COMMA,
+    STRICT_PERIOD,
+    OTHER_GROUPING_SEPARATORS,
+    ALL_SEPARATORS,
+    STRICT_ALL_SEPARATORS,
+
+    // Symbols
+    MINUS_SIGN,
+    PLUS_SIGN,
+    PERCENT_SIGN,
+    PERMILLE_SIGN,
+    INFINITY_KEY, // INFINITY is defined in cmath
+
+    // Currency Symbols
+    DOLLAR_SIGN,
+    POUND_SIGN,
+    RUPEE_SIGN,
+    YEN_SIGN, // not in CLDR data, but Currency.java wants it
+
+    // Other
+    DIGITS,
+
+    // Combined Separators with Digits (for lead code points)
+    DIGITS_OR_ALL_SEPARATORS,
+    DIGITS_OR_STRICT_ALL_SEPARATORS,
+
+    // The number of elements in the enum.
+    COUNT
+};
+
+/**
+ * Gets the static-allocated UnicodeSet according to the provided key. The
+ * pointer will be deleted during u_cleanup(); the caller should NOT delete it.
+ *
+ * Exported as U_COMMON_API for ucurr.cpp
+ *
+ * @param key The desired UnicodeSet according to the enum in this file.
+ * @return The requested UnicodeSet. Guaranteed to be frozen and non-null, but
+ *         may be empty if an error occurred during data loading.
+ */
+U_COMMON_API const UnicodeSet* get(Key key);
+
+/**
+ * Checks if the UnicodeSet given by key1 contains the given string.
+ *
+ * Exported as U_COMMON_API for numparse_decimal.cpp
+ *
+ * @param str The string to check.
+ * @param key1 The set to check.
+ * @return key1 if the set contains str, or NONE if not.
+ */
+U_COMMON_API Key chooseFrom(UnicodeString str, Key key1);
+
+/**
+ * Checks if the UnicodeSet given by either key1 or key2 contains the string.
+ *
+ * Exported as U_COMMON_API for numparse_decimal.cpp
+ *
+ * @param str The string to check.
+ * @param key1 The first set to check.
+ * @param key2 The second set to check.
+ * @return key1 if that set contains str; key2 if that set contains str; or
+ *         NONE if neither set contains str.
+ */
+U_COMMON_API Key chooseFrom(UnicodeString str, Key key1, Key key2);
+
+// Unused in C++:
+// Key chooseCurrency(UnicodeString str);
+// Used instead:
+static const struct {
+    Key key;
+    UChar32 exemplar;
+} kCurrencyEntries[] = {
+    {DOLLAR_SIGN, u'$'},
+    {POUND_SIGN, u'£'},
+    {RUPEE_SIGN, u'₨'},
+    {YEN_SIGN, u'¥'},
+};
+
+} // namespace unisets
+U_NAMESPACE_END
+
+#endif //__STATIC_UNICODE_SETS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/common/ubidi_props_data.h b/deps/icu-small/source/common/ubidi_props_data.h
index 98f21510e7d42c..55e331b612efcb 100644
--- a/deps/icu-small/source/common/ubidi_props_data.h
+++ b/deps/icu-small/source/common/ubidi_props_data.h
@@ -11,538 +11,539 @@
 
 #ifdef INCLUDED_FROM_UBIDI_PROPS_C
 
-static const UVersionInfo ubidi_props_dataVersion={0xa,0,0,0};
+static const UVersionInfo ubidi_props_dataVersion={0xb,0,0,0};
 
-static const int32_t ubidi_props_indexes[UBIDI_IX_TOP]={0x10,0x6028,0x5cb0,0x1a,0x620,0x8c0,0x10ac0,0x10af0,0,0,0,0,0,0,0,0x6302b6};
+static const int32_t ubidi_props_indexes[UBIDI_IX_TOP]={0x10,0x647c,0x5e98,0x28,0x620,0x8c0,0x10ac0,0x10d24,0,0,0,0,0,0,0,0x6502b6};
 
-static const uint16_t ubidi_props_trieIndex[11856]={
-0x36a,0x372,0x37a,0x382,0x39a,0x3a2,0x3aa,0x3b2,0x38a,0x392,0x38a,0x392,0x38a,0x392,0x38a,0x392,
-0x38a,0x392,0x38a,0x392,0x3b8,0x3c0,0x3c8,0x3d0,0x3d8,0x3e0,0x3dc,0x3e4,0x3ec,0x3f4,0x3ef,0x3f7,
-0x38a,0x392,0x38a,0x392,0x3ff,0x407,0x38a,0x392,0x38a,0x392,0x38a,0x392,0x40d,0x415,0x41d,0x425,
-0x42d,0x435,0x43d,0x445,0x44b,0x453,0x45b,0x463,0x46b,0x473,0x479,0x481,0x489,0x491,0x499,0x4a1,
-0x4ad,0x4a9,0x4b5,0x4bd,0x41f,0x4cd,0x4d5,0x4c5,0x4dd,0x4df,0x4e7,0x4ef,0x4f7,0x4f8,0x500,0x508,
-0x510,0x4f8,0x518,0x51d,0x510,0x4f8,0x525,0x52d,0x4f7,0x535,0x53d,0x4ef,0x542,0x38a,0x54a,0x54e,
-0x556,0x557,0x55f,0x567,0x4f7,0x56f,0x577,0x4ef,0x401,0x57b,0x500,0x4ef,0x38a,0x38a,0x583,0x38a,
-0x38a,0x589,0x591,0x38a,0x38a,0x595,0x59d,0x38a,0x5a1,0x5a8,0x38a,0x5b0,0x5b8,0x5bf,0x541,0x38a,
-0x38a,0x5c7,0x5cf,0x5d7,0x5df,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x5e7,0x38a,0x5ef,0x38a,0x38a,0x38a,
-0x5f7,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x5ff,0x38a,0x38a,0x38a,0x607,0x607,0x504,0x504,0x38a,0x60d,0x615,0x5ef,
-0x62b,0x61d,0x61d,0x633,0x63a,0x623,0x38a,0x38a,0x38a,0x642,0x64a,0x38a,0x38a,0x38a,0x64c,0x654,
-0x65c,0x38a,0x663,0x66b,0x38a,0x673,0x38a,0x38a,0x534,0x67b,0x542,0x683,0x401,0x68b,0x38a,0x692,
-0x38a,0x697,0x38a,0x38a,0x38a,0x38a,0x69d,0x6a5,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x3d8,0x6ad,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x6b5,0x6bd,0x6c1,
-0x6d9,0x6df,0x6c9,0x6d1,0x6e7,0x6ef,0x6f3,0x5c2,0x6fb,0x703,0x70b,0x38a,0x713,0x654,0x654,0x654,
-0x723,0x72b,0x733,0x73b,0x740,0x748,0x750,0x71b,0x758,0x760,0x38a,0x766,0x76d,0x654,0x654,0x654,
-0x654,0x56d,0x773,0x654,0x77b,0x38a,0x38a,0x651,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,
-0x654,0x654,0x654,0x654,0x654,0x783,0x654,0x654,0x654,0x654,0x654,0x789,0x654,0x654,0x791,0x799,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x654,0x654,0x654,0x654,0x7a9,0x7b0,0x7b8,0x7a1,
-0x7c8,0x7d0,0x7d8,0x7df,0x7e7,0x7ef,0x7f6,0x7c0,0x654,0x654,0x654,0x7fe,0x804,0x80a,0x812,0x817,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x81e,0x38a,0x38a,0x38a,0x826,0x38a,0x38a,0x38a,0x3d8,
-0x82e,0x836,0x763,0x38a,0x839,0x654,0x654,0x657,0x654,0x654,0x654,0x654,0x654,0x654,0x840,0x846,
-0x856,0x84e,0x38a,0x38a,0x85e,0x5f7,0x38a,0x3b1,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x654,0x825,
-0x3bf,0x38a,0x866,0x86e,0x38a,0x876,0x817,0x38a,0x38a,0x38a,0x38a,0x87e,0x38a,0x38a,0x64c,0x3b0,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x654,0x654,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x866,0x654,0x56d,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x885,0x38a,0x38a,0x88a,0x557,0x38a,0x38a,0x5a3,0x654,0x64b,0x38a,0x38a,0x892,0x38a,0x38a,0x38a,
-0x89a,0x8a1,0x61d,0x8a9,0x38a,0x38a,0x579,0x8b1,0x38a,0x8b8,0x8bf,0x38a,0x4dd,0x8c4,0x38a,0x4f6,
-0x38a,0x8cc,0x8d4,0x4f8,0x38a,0x8d8,0x4f7,0x8e0,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x8e7,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x8fb,0x8ef,0x8f3,0x489,0x489,0x489,0x489,0x489,
-0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x903,0x489,0x489,0x489,0x489,0x90b,0x90f,
-0x917,0x91f,0x923,0x92b,0x489,0x489,0x489,0x92f,0x937,0x37a,0x93f,0x947,0x38a,0x38a,0x38a,0x94f,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0xe28,0xe28,0xe68,0xea8,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xee0,0xf20,0xf60,0xf70,0xfb0,0xfbc,
-0xe28,0xe28,0xffc,0xe28,0xe28,0xe28,0x1034,0x1074,0x10b4,0x10f4,0x112c,0x116c,0x11ac,0x11e4,0x1224,0x1264,
-0xa40,0xa80,0xac0,0xafa,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xb25,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xb62,0x1a0,0x1a0,0xb97,0xbd7,0xc17,0xc57,0xc97,0xcd7,
+static const uint16_t ubidi_props_trieIndex[12100]={
+0x36f,0x377,0x37f,0x387,0x39f,0x3a7,0x3af,0x3b7,0x38f,0x397,0x38f,0x397,0x38f,0x397,0x38f,0x397,
+0x38f,0x397,0x38f,0x397,0x3bd,0x3c5,0x3cd,0x3d5,0x3dd,0x3e5,0x3e1,0x3e9,0x3f1,0x3f9,0x3f4,0x3fc,
+0x38f,0x397,0x38f,0x397,0x404,0x40c,0x38f,0x397,0x38f,0x397,0x38f,0x397,0x412,0x41a,0x422,0x42a,
+0x432,0x43a,0x442,0x44a,0x450,0x458,0x460,0x468,0x470,0x478,0x47e,0x486,0x48e,0x496,0x49e,0x4a6,
+0x4b2,0x4ae,0x4ba,0x4c2,0x424,0x4d2,0x4da,0x4ca,0x4e2,0x4e4,0x4ec,0x4f4,0x4fc,0x4fd,0x505,0x50d,
+0x515,0x4fd,0x51d,0x522,0x515,0x4fd,0x52a,0x532,0x4fc,0x53a,0x542,0x4f4,0x547,0x38f,0x54f,0x553,
+0x55b,0x55d,0x565,0x56d,0x4fc,0x575,0x57d,0x4f4,0x406,0x581,0x505,0x4f4,0x38f,0x38f,0x589,0x38f,
+0x38f,0x58f,0x597,0x38f,0x38f,0x59b,0x5a3,0x38f,0x5a7,0x5ae,0x38f,0x5b6,0x5be,0x5c5,0x546,0x38f,
+0x38f,0x5cd,0x5d5,0x5dd,0x5e5,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x5ed,0x38f,0x5f5,0x38f,0x38f,0x38f,
+0x5fd,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x605,0x38f,0x38f,0x38f,0x60d,0x60d,0x509,0x509,0x38f,0x613,0x61b,0x5f5,
+0x631,0x623,0x623,0x639,0x640,0x629,0x38f,0x38f,0x38f,0x648,0x650,0x38f,0x38f,0x38f,0x652,0x65a,
+0x662,0x38f,0x669,0x671,0x38f,0x679,0x38f,0x38f,0x539,0x681,0x547,0x689,0x406,0x691,0x38f,0x698,
+0x38f,0x69d,0x38f,0x38f,0x38f,0x38f,0x6a3,0x6ab,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x3dd,0x6b3,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x6bb,0x6c3,0x6c7,
+0x6df,0x6e5,0x6cf,0x6d7,0x6ed,0x6f5,0x6f9,0x5c8,0x701,0x709,0x711,0x38f,0x719,0x65a,0x65a,0x65a,
+0x729,0x731,0x739,0x741,0x746,0x74e,0x756,0x721,0x75e,0x766,0x38f,0x76c,0x773,0x65a,0x65a,0x65a,
+0x65a,0x573,0x779,0x65a,0x781,0x38f,0x38f,0x657,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,
+0x65a,0x65a,0x65a,0x65a,0x65a,0x789,0x65a,0x65a,0x65a,0x65a,0x65a,0x78f,0x65a,0x65a,0x797,0x79f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x65a,0x65a,0x65a,0x65a,0x7af,0x7b7,0x7bf,0x7a7,
+0x7cf,0x7d7,0x7df,0x7e6,0x7ed,0x7f5,0x7f9,0x7c7,0x65a,0x65a,0x65a,0x801,0x807,0x65a,0x80d,0x810,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x818,0x38f,0x38f,0x38f,0x820,0x38f,0x38f,0x38f,0x3dd,
+0x828,0x830,0x835,0x38f,0x83d,0x65a,0x65a,0x65d,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x844,0x84a,
+0x85a,0x852,0x38f,0x38f,0x862,0x5fd,0x38f,0x3b6,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x65a,0x81f,
+0x3c4,0x38f,0x839,0x86a,0x38f,0x872,0x87a,0x38f,0x38f,0x38f,0x38f,0x87e,0x38f,0x38f,0x652,0x3b5,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x65a,0x65a,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x839,0x65a,0x573,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x885,0x38f,0x38f,0x88a,0x55d,0x38f,0x38f,0x5a9,0x65a,0x651,0x38f,0x38f,0x892,0x38f,0x38f,0x38f,
+0x89a,0x8a1,0x623,0x8a9,0x38f,0x38f,0x57f,0x8b1,0x38f,0x8b9,0x8c0,0x38f,0x4e2,0x8c5,0x38f,0x4fb,
+0x38f,0x8cd,0x8d5,0x4fd,0x38f,0x8d9,0x4fc,0x8e1,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x8e8,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x8fc,0x8f0,0x8f4,0x48e,0x48e,0x48e,0x48e,0x48e,
+0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,0x904,0x48e,0x48e,0x48e,0x48e,0x90c,0x910,
+0x918,0x920,0x924,0x92c,0x48e,0x48e,0x48e,0x930,0x938,0x37f,0x940,0x948,0x38f,0x38f,0x38f,0x950,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0xe3c,0xe3c,0xe7c,0xebc,0xe3c,0xe3c,0xe3c,0xe3c,0xe3c,0xe3c,0xef4,0xf34,0xf74,0xf84,0xfc4,0xfd0,
+0xe3c,0xe3c,0x1010,0xe3c,0xe3c,0xe3c,0x1048,0x1088,0x10c8,0x1108,0x1140,0x1180,0x11c0,0x11f8,0x1238,0x1278,
+0xa40,0xa80,0xac0,0xaff,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xb37,0x1a0,0x1a0,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xb74,0x1a0,0x1a0,0xba9,0xbe9,0xc29,0xc69,0xca9,0xce9,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
-0xd57,0xd67,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
+0xd69,0xd79,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
 0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,
-0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd17,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x957,0x38a,0x654,0x654,0x95f,0x5f7,0x38a,0x4f0,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x967,0x38a,0x38a,0x38a,0x96e,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x976,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,
-0x97e,0x982,0x41f,0x41f,0x41f,0x41f,0x992,0x98a,0x41f,0x99a,0x41f,0x41f,0x9a2,0x9a8,0x41f,0x41f,
-0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,
-0x41f,0x41f,0x41f,0x9b0,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,
-0x4f7,0x9b8,0x9bf,0x9c6,0x401,0x9c9,0x38a,0x38a,0x4dd,0x9d1,0x38a,0x9d7,0x401,0x9dc,0x609,0x38a,
-0x38a,0x9e4,0x38a,0x38a,0x38a,0x38a,0x826,0x9ec,0x401,0x4f8,0x556,0x9f3,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x9b8,0x9fb,0x38a,0x38a,0x9ff,0xa07,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xa0b,0xa13,0x38a,
-0x38a,0xa1b,0x556,0xa23,0x38a,0xa29,0x38a,0x38a,0x5e7,0xa31,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xa39,0xa3d,0xa45,0x38a,0xa4c,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xa53,0x38a,0x38a,0xa61,0xa5b,
-0x38a,0x38a,0x38a,0xa69,0xa71,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xa75,0x38a,0xa7b,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0xa81,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x511,0xa89,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0xa90,0xa98,0xa9e,0x38a,0x38a,0x654,0x654,0xaa6,0x38a,0x38a,0x38a,0x38a,0x38a,0x654,
-0x654,0xaae,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xab4,0x38a,0xabb,
-0x38a,0xab7,0x38a,0xabe,0x38a,0xac6,0xaca,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x3d8,0xad2,0x3d8,0xad9,0xae0,0xae8,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xaf0,0xaf8,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0xb00,0x41f,0xb08,
-0xb08,0xb0f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,
-0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,
-0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0xb17,0x41f,
-0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x41f,0x654,0xb1f,0x654,0x654,0x657,0xb24,0xb28,0x840,0xb30,
-0x38a,0x38a,0xb36,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x764,0x38a,0x38a,0x38a,0x38a,0x654,
-0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,
-0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0xb3e,0xb46,0x654,
-0x654,0x654,0x657,0x654,0x654,0xb3e,0x38a,0xb1f,0x654,0xb4e,0x654,0xb56,0x842,0x38a,0x38a,0xb1f,
-0xb5a,0xb62,0x659,0x656,0x38a,0xb6a,0x56d,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xb72,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x38a,0x38a,0xb72,0xb82,0xb7a,0xb7a,0xb7a,0xb83,0xb83,0xb83,0xb83,0x3d8,
-0x3d8,0x3d8,0x3d8,0x3d8,0x3d8,0x3d8,0xb8b,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,
-0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,
-0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,
-0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,
-0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0xb83,0x369,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
-0x12,8,7,8,9,7,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,7,7,7,8,9,0xa,0xa,4,4,4,0xa,0xa,
-0x310a,0xf20a,0xa,3,6,3,6,6,2,2,2,2,2,2,2,2,
-2,2,6,0xa,0x500a,0xa,0xd00a,0xa,0xa,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x510a,0xa,0xd20a,0xa,0xa,0xa,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x510a,0xa,0xd20a,0xa,0x12,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x12,0x12,0x12,0x12,0x12,7,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,6,0xa,4,4,4,4,0xa,0xa,
-0xa,0xa,0,0x900a,0xa,0xb2,0xa,0xa,4,4,2,2,0xa,0,0xa,0xa,
-0xa,2,0,0x900a,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,
+0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0x1a0,0xd29,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x958,0x38f,0x65a,0x65a,0x960,0x5fd,0x38f,0x4f5,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x968,0x38f,0x38f,0x38f,0x96f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x977,0x424,0x424,0x424,0x424,0x424,0x424,0x424,
+0x97f,0x983,0x424,0x424,0x424,0x424,0x993,0x98b,0x424,0x99b,0x424,0x424,0x9a3,0x9a9,0x424,0x424,
+0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x9b9,0x9b1,0x424,0x424,0x424,0x424,0x424,0x424,
+0x424,0x424,0x424,0x9c1,0x424,0x424,0x424,0x424,0x424,0x9c9,0x9d0,0x9d6,0x424,0x424,0x424,0x424,
+0x4fc,0x9de,0x9e5,0x9ec,0x406,0x9ef,0x38f,0x38f,0x4e2,0x9f6,0x38f,0x9fc,0x406,0xa01,0xa09,0x38f,
+0x38f,0xa0e,0x38f,0x38f,0x38f,0x38f,0x820,0xa16,0x406,0x581,0x55c,0xa1d,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x9de,0xa25,0x38f,0x38f,0xa2d,0xa35,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xa39,0xa41,0x38f,
+0x38f,0xa49,0x55c,0xa51,0x38f,0xa57,0x38f,0x38f,0x5ed,0xa5f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0xa64,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xa6c,
+0xa70,0xa78,0x38f,0xa7f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0xa86,0x38f,0x38f,0xa94,0xa8e,0x38f,0x38f,0x38f,0xa9c,0xaa4,0x38f,0xaa8,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x583,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xaae,0x38f,
+0xab4,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0xaba,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x516,0xac2,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0xac9,0xad1,0xad7,0x38f,0x38f,0x65a,0x65a,0xadf,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x65a,0x65a,0x833,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xae1,
+0x38f,0xae8,0x38f,0xae4,0x38f,0xaeb,0x38f,0xaf3,0xaf7,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x3dd,0xaff,0x3dd,0xb06,0xb0d,0xb15,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xb1d,0xb25,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x424,0x424,0x424,0x424,0x424,0x424,0xb2d,
+0x424,0xb35,0xb35,0xb3c,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,
+0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x8f4,0x48e,0x48e,0x424,
+0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,0x48e,
+0xb44,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x424,0x65a,0xb4c,0x65a,0x65a,0x65d,0xb51,0xb55,
+0x844,0xb5d,0x3b1,0x38f,0xb63,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x76a,0x38f,0x38f,0x38f,
+0x38f,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,
+0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0xb6b,
+0xb73,0x65a,0x65a,0x65a,0x65d,0x65a,0x65a,0xb7b,0x38f,0xb4c,0x65a,0xb83,0x65a,0xb8b,0x846,0x38f,
+0x38f,0xb4c,0xb8f,0x65a,0xb97,0x65a,0xb9f,0xba7,0x65a,0x38f,0x38f,0x38f,0x846,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xbaf,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,
+0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0x38f,0xbaf,0xbbf,0xbb7,0xbb7,0xbb7,0xbc0,0xbc0,0xbc0,
+0xbc0,0x3dd,0x3dd,0x3dd,0x3dd,0x3dd,0x3dd,0x3dd,0xbc8,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,
+0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,
+0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,
+0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,
+0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0xbc0,0x36e,0x36e,0x36e,0x12,0x12,0x12,0x12,
+0x12,0x12,0x12,0x12,0x12,8,7,8,9,7,0x12,0x12,0x12,0x12,0x12,0x12,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,7,7,7,8,9,0xa,0xa,4,
+4,4,0xa,0xa,0x310a,0xf20a,0xa,3,6,3,6,6,2,2,2,2,
+2,2,2,2,2,2,6,0xa,0x500a,0xa,0xd00a,0xa,0xa,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,
+0,0,0,0,0,0,0,0x510a,0xa,0xd20a,0xa,0xa,0xa,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0x510a,0xa,0xd20a,0xa,0x12,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xa,0xa,0,0,0,0,0,
-0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x12,0x12,0x12,0x12,
+0x12,7,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,6,0xa,4,4,
+4,4,0xa,0xa,0xa,0xa,0,0x900a,0xa,0xb2,0xa,0xa,4,4,2,2,
+0xa,0,0xa,0xa,0xa,2,0,0x900a,0xa,0xa,0xa,0xa,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0,
+0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0,0,0,0xa,0xa,0,0,0,0,0,0,0,0,0xa,0,
-0,0,0,0,0xa,0xa,0,0xa,0,0,0,0,0,0,0,0,
+0xb1,0xb1,0xb1,0xb1,0,0,0,0,0xa,0xa,0,0,0,0,0,0,
+0,0,0xa,0,0,0,0,0,0xa,0xa,0,0xa,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xa,0,0,0,0,0,0,0,0,0,
+0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,0,
-0,0xa,0xa,4,1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0xa,0,0,0xa,0xa,4,1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,1,0xb1,1,0xb1,0xb1,1,0xb1,0xb1,1,0xb1,1,1,1,1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,0xb1,1,0xb1,0xb1,1,0xb1,0xb1,1,0xb1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,5,5,5,5,5,5,0xa,0xa,0xd,4,4,0xd,
-6,0xd,0xa,0xa,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xd,
-0x8ad,0xd,0xd,0xd,0x4d,0xd,0x8d,0x8d,0x8d,0x8d,0x4d,0x8d,0x4d,0x8d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x4d,0x2d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x4d,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,5,5,5,5,5,5,5,5,5,5,4,5,
-5,0xd,0x4d,0x4d,0xb1,0x8d,0x8d,0x8d,0xd,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,
-0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+1,1,1,1,1,1,1,1,5,5,5,5,5,5,0xa,0xa,
+0xd,4,4,0xd,6,0xd,0xa,0xa,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xd,0x8ad,0xd,0xd,0xd,0x4d,0xd,0x8d,0x8d,0x8d,0x8d,0x4d,0x8d,
+0x4d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x2d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x8d,0x4d,0x4d,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,5,5,5,5,5,5,5,5,
+5,5,4,5,5,0xd,0x4d,0x4d,0xb1,0x8d,0x8d,0x8d,0xd,0x8d,0x8d,0x8d,
+0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,
+0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
 0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x4d,0x8d,
-0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x8d,0x4d,0x8d,0x4d,0x4d,0x8d,0x8d,
-0xd,0x8d,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,5,0xa,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xd,0xd,0xb1,0xb1,0xa,0xb1,0xb1,0xb1,0xb1,0x8d,0x8d,2,2,2,2,
-2,2,2,2,2,2,0x4d,0x4d,0x4d,0xd,0xd,0x4d,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xad,0x8d,0xb1,0x4d,0x4d,
-0x4d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x8d,0x4d,0x8d,0x4d,0x4d,0x8d,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xd,
-0xd,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,
-0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,
-0x8d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x8d,0x8d,0x4d,0x4d,0x4d,0x8d,0x8d,0x4d,0x4d,
-0x4d,0x4d,0x4d,0x4d,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x8d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x8d,0x4d,0x8d,
+0x4d,0x4d,0x8d,0x8d,0xd,0x8d,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,5,0xa,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xd,0xd,0xb1,0xb1,0xa,0xb1,0xb1,0xb1,0xb1,0x8d,0x8d,
+2,2,2,2,2,2,2,2,2,2,0x4d,0x4d,0x4d,0xd,0xd,0x4d,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xad,
+0x8d,0xb1,0x4d,0x4d,0x4d,0x8d,0x8d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,
+0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x8d,0x4d,0x8d,0x4d,0x4d,0x8d,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xd,0xd,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x8d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x4d,0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x8d,0x4d,0x8d,0x8d,0x4d,0x4d,0x4d,
+0x8d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
 0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,1,1,1,1,1,1,1,1,1,1,0x41,0x41,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,1,1,1,1,1,1,1,1,
+1,1,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,
 0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,
-0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,0xa,0xa,0xa,0xa,0x21,1,
-1,1,1,1,0xb1,0xb1,0xb1,0xb1,1,0xb1,0xb1,0xb1,1,0xb1,0xb1,0xb1,
-0xb1,0xb1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0xb1,0xb1,0xb1,0xb1,1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0x81,0x41,0x41,0x41,0x41,0x41,0x81,0x81,0x41,0x81,0x41,0x41,
-0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x81,0x41,1,1,1,0xb1,0xb1,0xb1,
-1,1,1,1,0x4d,0xd,0x4d,0x4d,0x4d,0x4d,0xd,0x8d,0x4d,0x8d,0x8d,0xd,
-0xd,0xd,0xd,0xd,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,0xb1,0xb1,5,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0x41,0x41,0x41,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,0xa,0xa,
+0xa,0xa,0x21,1,1,0xb1,1,1,0xb1,0xb1,0xb1,0xb1,1,0xb1,0xb1,0xb1,
+1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,0xb1,0xb1,
+0xb1,0xb1,1,0xb1,0xb1,0xb1,0xb1,0xb1,0x81,0x41,0x41,0x41,0x41,0x41,0x81,0x81,
+0x41,0x81,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x81,0x41,1,1,
+1,0xb1,0xb1,0xb1,1,1,1,1,0x4d,0xd,0x4d,0x4d,0x4d,0x4d,0xd,0x8d,
+0x4d,0x8d,0x8d,0xd,0xd,0xd,0xd,0xd,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0xb1,0xb1,5,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x8d,0x8d,
-0x8d,0xd,0x8d,0x4d,0x4d,0x8d,0x8d,0x4d,0x4d,0xd,0x4d,0x4d,0x4d,0x8d,0x4d,0x4d,
-0x4d,0x4d,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xb1,0,0xb1,0,0,0,0,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0xb1,0,0,0,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0,0,
-0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x8d,0x8d,0x8d,0xd,0x8d,0x4d,0x4d,0x8d,0x8d,0x4d,0x4d,0xd,0x4d,0x4d,
+0x4d,0x8d,0x4d,0x4d,0x4d,0x4d,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xb1,0,0xb1,0,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0xb1,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,
 0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,4,4,0,0,0,0,0,0,0,4,0,0,0,0,
-0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xb1,0xb1,0,0,0,0,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0,0,
 0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xb1,0xb1,0,0,0,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0xb1,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
 0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xb1,0,0,0xb1,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
-0,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,4,4,0,0,0,0,0,0,0,4,
+0,0,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,
-0xa,4,0xa,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,
+0,0,0,0,0,0xb1,0xb1,0,0,0,0,0xb1,0xb1,0,0,0xb1,
+0xb1,0xb1,0,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,0,0xb1,0,0,
+0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,
+0xb1,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
+0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,
-0,0,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
-0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
+0,0,0,0,0xb1,0,0,0xb1,0,0xb1,0xb1,0xb1,0xb1,0,0,0,
+0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,0xb1,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0,0,
+0,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,
+0xa,0xa,0xa,0xa,0xa,4,0xa,0,0,0,0,0,0xb1,0,0,0,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0,0,0xa0,0,0,0,0,
-0,0,0xa0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,
+0,0,0xb1,0xb1,0xb1,0,0,0,0,0,0xb1,0xb1,0xb1,0,0xb1,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
-0,0,0,4,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,
-0xb1,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
+0xb1,0,0,0xa0,0,0,0,0,0,0,0xa0,0,0,0,0,0,
 0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0,0xb1,0,0xb1,0x310a,0xf20a,0x310a,0xf20a,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
-0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xb1,0xb1,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
 0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,
-0,0xb1,0xb1,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,4,0,0,0,0,
+0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,0,
+0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,0xb1,
+0,0xb1,0x310a,0xf20a,0x310a,0xf20a,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,
+0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,
+0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,
+0,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,
+0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0xa,0,0,0,
+0,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,
+0,0,0,0,0xa,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,
+0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x310a,
+0xf20a,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x310a,0xf20a,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,4,
-0,0xb1,0,0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-0x40,0x40,0x40,0x40,0x40,0xb1,0x40,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0x4a,0xa,0xa,0x2a,0xb1,0xb1,0xb1,0x12,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x40,0x40,0x40,0x40,
+0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
+0,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0,0,0,0,0,0,4,0,0xb1,0,0,0x40,0x40,0x40,0x40,
 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-0x40,0x40,0x40,0x40,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0x40,
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xb1,0x40,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x4a,0xa,0xa,0x2a,0xb1,
+0xb1,0xb1,0x12,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
+0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0,0,0,
+0,0,0,0,0,0xb1,0xb1,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xb1,0xb1,0xb1,0,0,0,0,0xb1,
-0xb1,0,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,
-0,0xb1,0xb1,0xb1,0,0,0,0,0xa,0,0,0,0xa,0xa,0,0,
+0xb1,0xb1,0xb1,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0,
+0,0,0xb1,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,0,
+0xa,0,0,0,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0,0,0xb1,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0xb1,0,
-0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0xb1,0,0,0xb1,0xb1,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0,
-0xb1,0xb1,0,0,0,0xb1,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,
-0,0xb1,0,0,0,0,0,0,0xb1,0,0,0,0xb1,0xb1,0,0,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
+0xb1,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xb1,0,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0,0xb1,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xa,0,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
-0,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0xa,0xa,0,0xa,0xa,0xa,0xa,6,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,9,0xb2,0xb2,0xb2,0xb2,0xb2,0x12,0x814,0x815,0x813,0x816,0xb2,0xb2,
-0xb2,0xb2,0xb2,0xb2,2,0,0,0,2,2,2,2,2,2,3,3,
-0xa,0x310a,0xf20a,0,9,9,9,9,9,9,9,9,9,9,9,0xb2,
-0x412,0x432,0x8a0,0x8a1,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,9,7,0x8ab,0x8ae,0x8b0,0x8ac,0x8af,6,4,4,4,4,
-4,0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,2,2,2,2,
-2,2,2,2,2,2,3,3,0xa,0x310a,0xf20a,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,
+0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0,0xb1,0xb1,0,0,0,0xb1,0,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0xb1,0,0,0,0,0,0,
+0xb1,0,0,0,0xb1,0xb1,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0xa,0,0xa,0xa,0xa,0,0,
+0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0xa,0xa,0,0xa,0xa,0xa,0xa,
+6,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,9,0xb2,0xb2,0xb2,0xb2,
+0xb2,0x12,0x814,0x815,0x813,0x816,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,2,0,0,0,
+2,2,2,2,2,2,3,3,0xa,0x310a,0xf20a,0,9,9,9,9,
+9,9,9,9,9,9,9,0xb2,0x412,0x432,0x8a0,0x8a1,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,9,7,0x8ab,0x8ae,
+0x8b0,0x8ac,0x8af,6,4,4,4,4,4,0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,
+0xa,0xa,0xa,0xa,2,2,2,2,2,2,2,2,2,2,3,3,
+0xa,0x310a,0xf20a,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,4,4,4,4,4,4,4,4,4,4,4,4,
 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,4,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xa,0xa,0,0xa,
-0xa,0xa,0xa,0,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
-0xa,0,0xa,0xa,0xa,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0xa,0,0xa,0,0xa,0,0,0,0,4,0,0,0,0,0,
-0,0,0,0,0,0,0xa,0xa,0,0,0,0,0x100a,0xa,0xa,0xa,
-0xa,0,0,0,0,0,0xa,0xa,0xa,0xa,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,
-0,0,0,0,0,0xa,0xa,0xa,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,
-0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0x300a,0xf00a,0x900a,0x900a,
-0x900a,0x100a,0x900a,0x900a,0x100a,0x100a,0x900a,0x900a,0x900a,0x900a,0x900a,0x100a,0xa,0x100a,0x100a,0x100a,
-0x100a,0xa,0xa,0xa,0x700a,0x700a,0x700a,0xb00a,0xb00a,0xb00a,0xa,0xa,0xa,0x100a,3,4,
-0xa,0x900a,0x100a,0xa,0xa,0xa,0x100a,0x100a,0x100a,0x100a,0xa,0x100a,0x100a,0x100a,0x100a,0xa,
-0x100a,0xa,0x100a,0xa,0xa,0xa,0xa,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0xa,0xa,0xa,0xa,0xa,0x100a,0xa,0x100a,0x300a,0xf00a,0x100a,0x100a,0x100a,0x100a,0x100a,0x900a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,
-0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0xa,0x100a,0xa,
-0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
-0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0xa,0x300a,
-0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0x300a,0xf00a,0xa,0xa,0x900a,0x100a,0x900a,0x900a,0x100a,0x900a,0x100a,0x100a,0x100a,0x100a,
-0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x900a,0xa,0xa,
-0x300a,0xf00a,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,
+4,4,4,4,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xa,0xa,0,0xa,0xa,0xa,0xa,0,0xa,0xa,0,0,
+0,0,0,0,0,0,0,0,0xa,0,0xa,0xa,0xa,0,0,0,
+0,0,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0,0xa,0,0xa,0,0,
+0,0,4,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,
+0,0,0,0,0x100a,0xa,0xa,0xa,0xa,0,0,0,0,0,0xa,0xa,
+0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
+0x300a,0xf00a,0xa,0xa,0x300a,0xf00a,0x900a,0x900a,0x900a,0x100a,0x900a,0x900a,0x100a,0x100a,0x900a,0x900a,
+0x900a,0x900a,0x900a,0x100a,0xa,0x100a,0x100a,0x100a,0x100a,0xa,0xa,0xa,0x700a,0x700a,0x700a,0xb00a,
+0xb00a,0xb00a,0xa,0xa,0xa,0x100a,3,4,0xa,0x900a,0x100a,0xa,0xa,0xa,0x100a,0x100a,
+0x100a,0x100a,0xa,0x900a,0x900a,0x900a,0x900a,0xa,0x900a,0xa,0x100a,0xa,0xa,0xa,0xa,0x100a,
+0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0x100a,0xa,0x100a,
+0x300a,0xf00a,0x100a,0x100a,0x100a,0x100a,0x100a,0x900a,0x100a,0x900a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
+0x900a,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0x100a,0x100a,0xa,0x100a,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
+0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
+0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,
+0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,0x900a,0x100a,
+0x900a,0x900a,0x100a,0x900a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
+0x900a,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0x300a,0xf00a,0x300a,0xf00a,0x900a,0xa,0xa,0x300a,0xf00a,0xa,0xa,0xa,0xa,0x300a,0xf00a,
+0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
+0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,
-0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0x100a,0xa,0xa,0x300a,0xf00a,0x310a,0xf20a,0xa,0x300a,0xf00a,0xa,0x500a,
-0x100a,0xd00a,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,
-0x100a,0x300a,0xf00a,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,
-0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0x100a,0xa,0x100a,0x100a,0x100a,0xa,0xa,0x100a,0x100a,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x900a,0x100a,0x100a,0x300a,0xf00a,0xa,0xa,
-0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,
-0xf20a,0x710a,0x320a,0xf10a,0xb20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0x300a,0xf00a,0x100a,0x100a,0x300a,0xf00a,0xa,0xa,0xa,0x100a,0xa,0xa,0xa,0xa,0x100a,0x300a,
-0xf00a,0x300a,0xf00a,0xa,0x300a,0xf00a,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x100a,0xa,0xa,0xa,
-0xa,0xa,0x100a,0x900a,0x900a,0x900a,0x100a,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x100a,0xa,
-0xa,0xa,0xa,0x100a,0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0x100a,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0xa,0x100a,0x100a,
-0x100a,0x100a,0xa,0xa,0x100a,0xa,0x100a,0xa,0xa,0x100a,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,
-0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x100a,0xa,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,
+0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0xa,0xa,0x300a,
+0xf00a,0x310a,0xf20a,0xa,0x300a,0xf00a,0xa,0x500a,0x100a,0xd00a,0xa,0xa,0xa,0xa,0xa,0x100a,
+0x100a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0x900a,0x300a,0xf00a,0xa,0xa,0xa,0x300a,0xf00a,
+0x300a,0xf00a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0xa,0x100a,
+0x100a,0x100a,0xa,0xa,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0x100a,0x900a,0x100a,0x100a,0x300a,0xf00a,0xa,0xa,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0x310a,
+0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x710a,0x320a,0xf10a,0xb20a,0x310a,0xf20a,0x310a,
+0xf20a,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0x900a,0x100a,0x100a,0x100a,0x100a,0x900a,0xa,0x100a,0x900a,
+0x300a,0xf00a,0x100a,0x100a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x100a,0x100a,
+0x300a,0xf00a,0xa,0xa,0xa,0x100a,0xa,0xa,0xa,0xa,0x100a,0x300a,0xf00a,0x300a,0xf00a,0xa,
+0x300a,0xf00a,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x100a,0xa,0xa,0xa,0xa,0xa,0x100a,0x900a,
+0x900a,0x900a,0x100a,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x900a,0xa,0xa,0xa,0xa,0x100a,
+0xa,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
+0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0xa,0x100a,0x100a,0x100a,0x100a,0xa,0xa,
+0x100a,0xa,0x100a,0xa,0xa,0x100a,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,
+0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x100a,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0x300a,0xf00a,0xa,0xa,0xa,0xa,0x100a,0x100a,0x100a,0x100a,0xa,0x100a,0x100a,0xa,0xa,0x100a,
-0x100a,0xa,0xa,0xa,0xa,0x300a,0xf00a,0x100a,0x100a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,
-0xf00a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x300a,
-0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x100a,
-0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0x300a,0xf00a,0x100a,0x100a,0x300a,
-0xf00a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,
-0xa,0xa,0xa,0xa,0x100a,0xa,0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0xa,0xa,
+0xa,0xa,0xa,0x100a,0x100a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,
+0xa,0xa,0x100a,0x100a,0x100a,0x100a,0xa,0x100a,0x100a,0xa,0xa,0x100a,0x100a,0xa,0xa,0xa,
+0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,
+0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,
+0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x100a,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,
+0x300a,0xf00a,0xa,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,
+0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,
+0x100a,0xa,0x900a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x900a,0,
+0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
+0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,0xa,0x300a,0xf00a,0xa,0x300a,0xf00a,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,
+0x300a,0xf00a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,
-0xa,0xa,0xa,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,
-0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xa,0xa,0x300a,0xf00a,0x300a,0xf00a,0xa,0xa,
-0xa,0x300a,0xf00a,0xa,0x300a,0xf00a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0x300a,0xf00a,0xa,0xa,0x300a,0xf00a,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,
-0x310a,0xf20a,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
@@ -554,12 +555,11 @@ static const uint16_t ubidi_props_trieIndex[11856]={
 0x310a,0xf20a,0x310a,0xf20a,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0xb1,0xb1,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
+0,0,0,0,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa,
 0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -574,194 +574,211 @@ static const uint16_t ubidi_props_trieIndex[11856]={
 0x40,0x40,0x40,0x40,0x40,0x40,0x60,0,0xa,0xa,0xa,0xa,0,0,0,0,
 0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,
+0,0,0,0xb1,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0,0,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xb1,0,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,
+0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,
+0,0,0,0,0,0xb1,0,0,0xb1,0,0,0,0,0xb1,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0,0,0,
-0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
-0,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,
-0,0,0,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0,
+1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xb1,0,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,0xb1,0xb1,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,
-0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,0,
-0,0xb1,0,0,0xb1,0,0,0,0,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
-1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,1,0xb1,1,0xd,0xd,0xd,0xd,
+0,0,0,0,0,0,0,0,0,0,0,0,0,1,0xb1,1,
 0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xa,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xd,0xd,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,6,0xa,6,0,
-0xa,6,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,4,0xa,0xa,3,3,
-0x300a,0xf00a,0xa,0,0xa,4,4,0xa,0,0,0,0,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xa,
 0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb2,0,0xa,0xa,4,
-4,4,0xa,0xa,0x310a,0xf20a,0xa,3,6,3,6,6,2,2,2,2,
-2,2,2,2,2,2,6,0xa,0x500a,0xa,0xd00a,0xa,0xa,0,0,0,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xd,0xd,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+6,0xa,6,0,0xa,6,0xa,0xa,0xa,0x310a,0xf20a,0x310a,0xf20a,0x310a,0xf20a,4,
+0xa,0xa,3,3,0x300a,0xf00a,0xa,0,0xa,4,4,0xa,0,0,0,0,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xb2,
+0,0xa,0xa,4,4,4,0xa,0xa,0x310a,0xf20a,0xa,3,6,3,6,6,
+2,2,2,2,2,2,2,2,2,2,6,0xa,0x500a,0xa,0xd00a,0xa,
+0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0x510a,0xa,0xd20a,0xa,0x310a,
+0xf20a,0xa,0x310a,0xf20a,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x510a,0xa,0xd20a,0xa,0x310a,0xf20a,0xa,0x310a,0xf20a,
-0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,0xa,0xa,
-0xa,4,4,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0xaa,0xaa,0xaa,0xa,0xa,0x12,0x12,0,0xa,0,0,
+4,4,0xa,0xa,0xa,4,4,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0xaa,0xaa,0xaa,0xa,0xa,0x12,0x12,
+0,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0xb1,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0,0,0,0,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xa,1,0xb1,0xb1,0xb1,1,0xb1,0xb1,1,
-1,1,1,1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,1,1,1,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,
+0xb1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xb1,0xb1,0xb1,1,1,1,1,0xb1,0x41,0x81,1,1,0x81,0xb1,0xb1,1,
-1,1,1,0x41,0x41,0x41,0x41,0x81,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,0x41,0x41,0x41,0x41,0x41,0x81,1,0x81,
-1,0x81,0x81,1,1,0x61,0x81,0x81,0x81,0x81,0x81,0x41,0x41,0x41,0x41,0x61,
-0x41,0x41,0x41,0x41,0x41,0x81,0x41,0x41,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0xa,1,0xb1,0xb1,0xb1,
+1,0xb1,0xb1,1,1,1,1,1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x41,0x81,0x41,0x81,0x81,0x81,0x41,0x41,
-0x41,0x81,0x41,0x41,0x81,0x41,0x81,0x81,0x41,0x81,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,0x81,0x81,0x81,0x81,0x41,0x41,1,
+1,1,1,1,0xb1,0xb1,0xb1,1,1,1,1,0xb1,0x41,0x81,1,1,
+0x81,0xb1,0xb1,1,1,1,1,0x41,0x41,0x41,0x41,0x81,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,0x41,0x41,0x41,0x41,
+0x41,0x81,1,0x81,1,0x81,0x81,1,1,0x61,0x81,0x81,0x81,0x81,0x81,0x41,
+0x41,0x41,0x41,0x61,0x41,0x41,0x41,0x41,0x41,0x81,0x41,0x41,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0x41,0x81,0x41,0x81,
+0x81,0x81,0x41,0x41,0x41,0x81,0x41,0x41,0x81,0x41,0x81,0x81,0x41,0x81,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,0x81,0x81,0x81,
+0x81,0x41,0x41,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x4d,0x4d,0x8d,0x4d,0xb1,0xb1,0xb1,0xb1,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,5,5,5,5,5,5,5,5,5,5,0xd,0xd,
+0xd,0xd,0xd,0xd,0x6d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x4d,0x4d,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,1,
+5,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0x4d,0x4d,0x4d,0x8d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,0x4d,
+0x4d,0x4d,0x4d,0x4d,0x4d,0xd,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0x4d,0x4d,0x4d,0x8d,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,
-0,0xa0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
+0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,
+0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
-0xb1,0xb1,0,0,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,0xb1,0,
-0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,
+0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0xb1,0,0xb1,0xb1,
+0,0,0,0,0,0,0xb1,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,0xb1,0xb1,0,0xb1,0xb1,
+0,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,
+0,0,0,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
-0xb1,0xb1,0,0,0,0,0,0,0xb1,0xb1,0,0xb1,0xb1,0,0,0,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
+0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xb1,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0,0xb1,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,
+0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
+0,0xb1,0,0xb1,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0,0xb1,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,
+0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
-0,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,
-0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xa0,0xa0,0xb1,0xb1,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,
-0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,
-0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,
-0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xa0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,
-0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0,
+0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0,0,0,0,
 0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0xb1,0,
-0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,
+0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xa0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0xb1,0xb1,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xb2,0xb2,0xb2,0xb2,0,0,0,0,0,0,0,0,
+0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,0,0,0,0,
-0,0,0,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,
+0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0xb1,0,0xb1,0xb1,0,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xb1,0xb1,0xb1,0xa,0,0,
+0xb1,0xb1,0,0,0,0xb1,0,0xb1,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0xb2,0xb2,0xb2,0xb2,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x100a,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0,0,
+0,0,0,0,0,0,0,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0x100a,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x100a,0,0,0,0,
-0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,
-0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,
-0,0,0,0,0xb1,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0,0,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xb1,0xb1,
+0xb1,0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x100a,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,
+0,0,0,0,0,0x100a,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x100a,
+0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0xb1,0,0,
+0,0,0,0,0,0,0,0,0xb1,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xb1,
+0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0,0xb1,0xb1,0,0xb1,0xb1,0xb1,0xb1,0xb1,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,1,1,1,1,
-0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,
+0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,
+1,1,1,1,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,
 0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,0xd,0xd,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xa,0xd,0xd,
-0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,
-0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-2,2,2,2,2,2,2,2,2,2,2,0xa,0xa,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0xa,0xa,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0x41,0x41,0x41,0x41,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xa,0xa,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,0xd,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,
 0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
-0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,
+0xa,0xa,0xa,0,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,2,2,2,2,2,2,2,2,2,2,2,0xa,
+0xa,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0xa,0xa,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0xa,
+0xa,0xa,0xa,0,0,0,0xa,0,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,0,0,0xa,0xa,0xa,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xa,0xa,0xa,0xa,
+0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0xa,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x12,0x12,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,
+0,0,0,0,0,0,0,0,0,0,0x12,0x12,0xb2,0xb2,0xb2,0xb2,
 0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,
-0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0x12,0xb2,0x12,0x12,0x12,0x12,0x12,0x12,
+0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0xb2,0x12,0xb2,0x12,0x12,
 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0,0,0,0
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
+0,0,0,0
 };
 
-static const uint32_t ubidi_props_mirrors[26]={
-0x2000ab,0xbb,0x2a02215,0x1202243,0x2802298,0x2c022a6,0x30022a8,0x2e022a9,0x32022ab,0x6022cd,0x1e022f2,0x20022f3,0x22022f4,0x24022f6,0x26022f7,0x14022fa,
-0x16022fb,0x18022fc,0x1a022fd,0x1c022fe,0x8029b8,0x4029f5,0xa02ade,0xe02ae3,0xc02ae4,0x1002ae5
+static const uint32_t ubidi_props_mirrors[40]={
+0x2000ab,0xbb,0x4202215,0x4e0221f,0x3e02220,0x3a02221,0x3c02222,0x4c02224,0x2202243,0x1402245,0x120224c,0x4002298,0x44022a6,0x48022a8,0x46022a9,0x4a022ab,
+0x38022b8,0x10022cd,0x2e022f2,0x30022f3,0x32022f4,0x34022f6,0x36022f7,0x24022fa,0x26022fb,0x28022fc,0x2a022fd,0x2c022fe,0x20027dc,0xa0299b,0xc029a0,0x8029a3,
+0x16029b8,0x4029f5,0x1802ade,0x1c02ae3,0x1a02ae4,0x1e02ae5,0xe02aee,0x602bfe
 };
 
 static const uint8_t ubidi_props_jgArray[672]={
@@ -809,10 +826,46 @@ static const uint8_t ubidi_props_jgArray[672]={
 0xb,0x55,0x1f,1,0x13,0,4,4,4,0x1f,0x2d,0x56,0x58,0x57,0,0
 };
 
-static const uint8_t ubidi_props_jgArray2[48]={
+static const uint8_t ubidi_props_jgArray2[612]={
 0x3a,0x3c,0x3c,0x40,0x40,0x3d,0,0x52,0,0x54,0x54,0,0,0x41,0x4f,0x53,
 0x43,0x43,0x43,0x44,0x3e,0x50,0x45,0x46,0x4c,0x3b,0x3b,0x48,0x48,0x4b,0x49,0x49,
-0x49,0x4a,0,0,0x4d,0,0,0,0,0,0,0x47,0x3f,0x4e,0x51,0x42
+0x49,0x4a,0,0,0x4d,0,0,0,0,0,0,0x47,0x3f,0x4e,0x51,0x42,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0x65,0,0,0,0,0,0,0x65,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0x64,0,0,0x65,0,0x64,0,
+0x64,0,0,0x64
 };
 
 static const UBiDiProps ubidi_props_singleton={
@@ -823,16 +876,16 @@ static const UBiDiProps ubidi_props_singleton={
   ubidi_props_jgArray2,
   {
     ubidi_props_trieIndex,
-    ubidi_props_trieIndex+3496,
+    ubidi_props_trieIndex+3516,
     NULL,
-    3496,
-    8360,
+    3516,
+    8584,
     0x1a0,
-    0xe28,
+    0xe3c,
     0x0,
     0x0,
     0x110000,
-    0x2e4c,
+    0x2f40,
     NULL, 0, FALSE, FALSE, 0, NULL
   },
   { 2,2,0,0 }
diff --git a/deps/icu-small/source/common/ucase.cpp b/deps/icu-small/source/common/ucase.cpp
index 28d5a4cac62ba6..43c57f896e9348 100644
--- a/deps/icu-small/source/common/ucase.cpp
+++ b/deps/icu-small/source/common/ucase.cpp
@@ -138,6 +138,11 @@ ucase_tolower(UChar32 c) {
     } else {
         const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
         uint16_t excWord=*pe++;
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
             GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe, c);
         }
@@ -155,6 +160,11 @@ ucase_toupper(UChar32 c) {
     } else {
         const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
         uint16_t excWord=*pe++;
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
             GET_SLOT_VALUE(excWord, UCASE_EXC_UPPER, pe, c);
         }
@@ -172,6 +182,11 @@ ucase_totitle(UChar32 c) {
     } else {
         const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
         uint16_t excWord=*pe++;
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         int32_t idx;
         if(HAS_SLOT(excWord, UCASE_EXC_TITLE)) {
             idx=UCASE_EXC_TITLE;
@@ -254,6 +269,11 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
                 sa->add(sa->set, c);
             }
         }
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA)) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            sa->add(sa->set, (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta);
+        }
 
         /* get the closure string pointer & length */
         if(HAS_SLOT(excWord, UCASE_EXC_CLOSURE)) {
@@ -590,7 +610,12 @@ ucase_isSoftDotted(UChar32 c) {
 U_CAPI UBool U_EXPORT2
 ucase_isCaseSensitive(UChar32 c) {
     uint16_t props=UTRIE2_GET16(&ucase_props_singleton.trie, c);
-    return (UBool)((props&UCASE_SENSITIVE)!=0);
+    if(!UCASE_HAS_EXCEPTION(props)) {
+        return (UBool)((props&UCASE_SENSITIVE)!=0);
+    } else {
+        const uint16_t *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
+        return (UBool)((*pe&UCASE_EXC_SENSITIVE)!=0);
+    }
 }
 
 /* string casing ------------------------------------------------------------ */
@@ -1140,6 +1165,11 @@ ucase_toFullLower(UChar32 c,
             }
         }
 
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
             GET_SLOT_VALUE(excWord, UCASE_EXC_LOWER, pe2, result);
         }
@@ -1229,6 +1259,11 @@ toUpperOrTitle(UChar32 c,
             }
         }
 
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_GET_TYPE(props)==UCASE_LOWER) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(!upperNotTitle && HAS_SLOT(excWord, UCASE_EXC_TITLE)) {
             idx=UCASE_EXC_TITLE;
         } else if(HAS_SLOT(excWord, UCASE_EXC_UPPER)) {
@@ -1334,6 +1369,14 @@ ucase_fold(UChar32 c, uint32_t options) {
                 }
             }
         }
+        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
+            return c;
+        }
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
             idx=UCASE_EXC_FOLD;
         } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
@@ -1421,6 +1464,14 @@ ucase_toFullFolding(UChar32 c,
             }
         }
 
+        if((excWord&UCASE_EXC_NO_SIMPLE_CASE_FOLDING)!=0) {
+            return ~c;
+        }
+        if(HAS_SLOT(excWord, UCASE_EXC_DELTA) && UCASE_IS_UPPER_OR_TITLE(props)) {
+            int32_t delta;
+            GET_SLOT_VALUE(excWord, UCASE_EXC_DELTA, pe, delta);
+            return (excWord&UCASE_EXC_DELTA_IS_NEGATIVE)==0 ? c+delta : c-delta;
+        }
         if(HAS_SLOT(excWord, UCASE_EXC_FOLD)) {
             idx=UCASE_EXC_FOLD;
         } else if(HAS_SLOT(excWord, UCASE_EXC_LOWER)) {
diff --git a/deps/icu-small/source/common/ucase.h b/deps/icu-small/source/common/ucase.h
index a7a8c9f00d1e93..b0a453b87e8afa 100644
--- a/deps/icu-small/source/common/ucase.h
+++ b/deps/icu-small/source/common/ucase.h
@@ -354,8 +354,8 @@ enum {
 #define UCASE_IS_UPPER_OR_TITLE(props) ((props)&2)
 
 #define UCASE_IGNORABLE         4
-#define UCASE_SENSITIVE         8
-#define UCASE_EXCEPTION         0x10
+#define UCASE_EXCEPTION         8
+#define UCASE_SENSITIVE         0x10
 
 #define UCASE_HAS_EXCEPTION(props) ((props)&UCASE_EXCEPTION)
 
@@ -379,9 +379,9 @@ enum {
 #   define UCASE_GET_DELTA(props) (int16_t)(((props)&0x8000) ? (((props)>>UCASE_DELTA_SHIFT)|0xfe00) : ((uint16_t)(props)>>UCASE_DELTA_SHIFT))
 #endif
 
-/* exception: bits 15..5 are an unsigned 11-bit index into the exceptions array */
-#define UCASE_EXC_SHIFT     5
-#define UCASE_EXC_MASK      0xffe0
+/* exception: bits 15..4 are an unsigned 12-bit index into the exceptions array */
+#define UCASE_EXC_SHIFT     4
+#define UCASE_EXC_MASK      0xfff0
 #define UCASE_MAX_EXCEPTIONS ((UCASE_EXC_MASK>>UCASE_EXC_SHIFT)+1)
 
 /* definitions for 16-bit main exceptions word ------------------------------ */
@@ -392,7 +392,7 @@ enum {
     UCASE_EXC_FOLD,
     UCASE_EXC_UPPER,
     UCASE_EXC_TITLE,
-    UCASE_EXC_4,            /* reserved */
+    UCASE_EXC_DELTA,
     UCASE_EXC_5,            /* reserved */
     UCASE_EXC_CLOSURE,
     UCASE_EXC_FULL_MAPPINGS,
@@ -402,7 +402,11 @@ enum {
 /* each slot is 2 uint16_t instead of 1 */
 #define UCASE_EXC_DOUBLE_SLOTS      0x100
 
-/* reserved: exception bits 11..9 */
+enum {
+    UCASE_EXC_NO_SIMPLE_CASE_FOLDING=0x200,
+    UCASE_EXC_DELTA_IS_NEGATIVE=0x400,
+    UCASE_EXC_SENSITIVE=0x800
+};
 
 /* UCASE_EXC_DOT_MASK=UCASE_DOT_MASK<<UCASE_EXC_DOT_SHIFT */
 #define UCASE_EXC_DOT_SHIFT     7
diff --git a/deps/icu-small/source/common/ucase_props_data.h b/deps/icu-small/source/common/ucase_props_data.h
index fe620efc6e2cbc..eb7d9ff9099d18 100644
--- a/deps/icu-small/source/common/ucase_props_data.h
+++ b/deps/icu-small/source/common/ucase_props_data.h
@@ -11,145 +11,145 @@
 
 #ifdef INCLUDED_FROM_UCASE_CPP
 
-static const UVersionInfo ucase_props_dataVersion={0xa,0,0,0};
+static const UVersionInfo ucase_props_dataVersion={0xb,0,0,0};
 
-static const int32_t ucase_props_indexes[UCASE_IX_TOP]={0x10,0x6dfc,0x5ba0,0x79c,0x172,0,0,0,0,0,0,0,0,0,0,3};
+static const int32_t ucase_props_indexes[UCASE_IX_TOP]={0x10,0x6e72,0x5e50,0x67f,0x172,0,0,0,0,0,0,0,0,0,0,3};
 
-static const uint16_t ucase_props_trieIndex[11720]={
-0x327,0x32f,0x337,0x33f,0x34d,0x355,0x35d,0x365,0x36d,0x375,0x37c,0x384,0x38c,0x394,0x39c,0x3a4,
-0x3aa,0x3b2,0x3ba,0x3c2,0x3ca,0x3d2,0x3da,0x3e2,0x3ea,0x3f2,0x3fa,0x402,0x40a,0x412,0x41a,0x422,
-0x42a,0x432,0x43a,0x442,0x44a,0x452,0x45a,0x462,0x45e,0x466,0x46b,0x473,0x47a,0x482,0x48a,0x492,
-0x49a,0x4a2,0x4aa,0x4b2,0x346,0x34e,0x4b7,0x4bf,0x4c4,0x4cc,0x4d4,0x4dc,0x4db,0x4e3,0x4e8,0x4f0,
-0x4f7,0x4fe,0x502,0x346,0x346,0x327,0x512,0x50a,0x51a,0x51c,0x524,0x52c,0x530,0x531,0x539,0x541,
-0x549,0x531,0x551,0x556,0x549,0x531,0x55e,0x566,0x530,0x56e,0x576,0x541,0x57b,0x346,0x583,0x346,
-0x4a1,0x4dd,0x58b,0x541,0x530,0x56e,0x592,0x541,0x59a,0x59c,0x539,0x541,0x346,0x346,0x5a4,0x346,
-0x346,0x5aa,0x5b1,0x346,0x346,0x5b5,0x5bd,0x346,0x5c1,0x5c8,0x346,0x5cf,0x5d7,0x5de,0x5e6,0x346,
-0x346,0x5eb,0x5f3,0x5fb,0x603,0x60b,0x613,0x490,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x617,0x346,0x346,0x627,0x62f,0x61f,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x637,0x637,0x53d,0x53d,0x346,0x63d,0x645,0x346,
-0x64d,0x346,0x655,0x346,0x548,0x65b,0x346,0x346,0x346,0x663,0x346,0x346,0x346,0x346,0x346,0x346,
-0x66a,0x346,0x671,0x679,0x346,0x681,0x346,0x346,0x56d,0x689,0x691,0x697,0x59a,0x69f,0x346,0x6a6,
-0x346,0x6ab,0x346,0x6b1,0x6b9,0x346,0x6bd,0x6c5,0x6cd,0x6d2,0x6d5,0x6dd,0x6ed,0x6e5,0x6fd,0x6f5,
-0x36d,0x705,0x36d,0x70d,0x710,0x36d,0x718,0x36d,0x720,0x728,0x730,0x738,0x740,0x748,0x750,0x758,
-0x760,0x767,0x346,0x76f,0x777,0x346,0x77f,0x787,0x78f,0x797,0x79f,0x7a7,0x7af,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x7b2,0x7b8,0x7be,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x7c6,0x7cb,0x7cf,0x7d7,0x36d,0x36d,0x36d,0x7df,0x7e7,0x7ef,0x346,0x7f4,0x346,0x346,0x346,0x7fc,
-0x346,0x652,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x52f,0x804,0x346,0x346,0x80b,0x346,0x346,0x813,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x81b,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x6b1,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x821,0x346,0x829,0x82e,0x836,0x346,0x346,0x83e,0x846,0x84e,0x36d,0x853,0x85b,0x861,0x346,0x867,
-0x86f,0x548,0x346,0x346,0x346,0x346,0x876,0x87e,0x346,0x885,0x88c,0x346,0x51a,0x891,0x899,0x548,
-0x346,0x89f,0x8a7,0x8ab,0x346,0x8b3,0x8bb,0x8c3,0x346,0x8c9,0x8cd,0x8d5,0x8e5,0x8dd,0x346,0x8ed,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x8f5,0x346,0x346,0x346,0x346,0x8fd,0x59a,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x902,0x90a,0x90e,0x346,0x346,0x346,0x346,0x329,0x32f,0x916,0x91e,0x925,0x4dd,0x346,0x346,0x92d,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0xd1c,0xd1c,0xd34,0xd74,0xdb4,0xdf0,0xe30,0xe70,0xea8,0xee8,0xf28,0xf68,0xfa8,0xfe8,0x1028,0x1068,
-0x10a8,0x10e8,0x1128,0x1168,0x1178,0x11ac,0x11e8,0x1228,0x1268,0x12a8,0xd18,0x12dc,0x1310,0x1350,0x136c,0x13a0,
-0x9e1,0xa11,0xa51,0xa8c,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xab7,0x188,0x188,
-0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xaf7,0x188,0x188,0xb2c,0xb6b,0xbab,0xbe5,0xc1c,0x188,
+static const uint16_t ucase_props_trieIndex[12064]={
+0x32c,0x334,0x33c,0x344,0x352,0x35a,0x362,0x36a,0x372,0x37a,0x381,0x389,0x391,0x399,0x3a1,0x3a9,
+0x3af,0x3b7,0x3bf,0x3c7,0x3cf,0x3d7,0x3df,0x3e7,0x3ef,0x3f7,0x3ff,0x407,0x40f,0x417,0x41f,0x427,
+0x42f,0x437,0x43f,0x447,0x44f,0x457,0x45f,0x467,0x463,0x46b,0x470,0x478,0x47f,0x487,0x48f,0x497,
+0x49f,0x4a7,0x4af,0x4b7,0x34b,0x353,0x4bc,0x4c4,0x4c9,0x4d1,0x4d9,0x4e1,0x4e0,0x4e8,0x4ed,0x4f5,
+0x4fd,0x504,0x508,0x34b,0x34b,0x32c,0x518,0x510,0x520,0x522,0x52a,0x532,0x536,0x537,0x53f,0x547,
+0x54f,0x537,0x557,0x55c,0x54f,0x537,0x564,0x56c,0x536,0x574,0x57c,0x584,0x58c,0x34b,0x594,0x34b,
+0x59c,0x4e2,0x5a4,0x584,0x536,0x574,0x5ab,0x584,0x5b3,0x5b5,0x53f,0x584,0x34b,0x34b,0x5bd,0x34b,
+0x34b,0x5c3,0x5ca,0x34b,0x34b,0x5ce,0x5d6,0x34b,0x5da,0x5e1,0x34b,0x5e8,0x5f0,0x5f7,0x5ff,0x34b,
+0x34b,0x604,0x60c,0x614,0x61c,0x624,0x62b,0x633,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x63b,0x34b,0x34b,0x64b,0x64b,0x643,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x653,0x653,0x543,0x543,0x34b,0x659,0x661,0x34b,
+0x669,0x34b,0x671,0x34b,0x678,0x67e,0x34b,0x34b,0x34b,0x686,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x68d,0x34b,0x694,0x69c,0x34b,0x6a4,0x34b,0x34b,0x573,0x6ac,0x6b4,0x6ba,0x5b3,0x6c2,0x34b,0x6c9,
+0x34b,0x6ce,0x34b,0x6d4,0x6dc,0x6e0,0x6e8,0x6f0,0x6f8,0x6fd,0x700,0x708,0x718,0x710,0x728,0x720,
+0x372,0x730,0x372,0x738,0x73b,0x372,0x743,0x372,0x74b,0x753,0x75b,0x763,0x76b,0x773,0x77b,0x783,
+0x78b,0x792,0x34b,0x79a,0x7a2,0x34b,0x7aa,0x7b2,0x7ba,0x7c2,0x7ca,0x7d2,0x7da,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x7dd,0x7e3,0x7e9,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x7f1,0x7f6,0x7fa,0x802,0x372,0x372,0x372,0x80a,0x812,0x819,0x34b,0x81e,0x34b,0x34b,0x34b,0x826,
+0x34b,0x66e,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x535,0x82e,0x34b,0x34b,0x835,0x34b,0x34b,0x83d,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x845,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x6d4,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x84b,0x34b,0x853,0x858,0x860,0x34b,0x34b,0x868,0x870,0x878,0x372,0x87d,0x885,0x88b,0x34b,0x892,
+0x89a,0x678,0x34b,0x34b,0x34b,0x34b,0x8a1,0x8a9,0x34b,0x8b1,0x8b8,0x34b,0x520,0x8bd,0x8c5,0x678,
+0x34b,0x8cb,0x8d3,0x8d7,0x34b,0x8df,0x8e7,0x8ef,0x34b,0x8f5,0x8f9,0x901,0x911,0x909,0x34b,0x919,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x921,0x34b,0x34b,0x34b,0x34b,0x929,0x5b3,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x92e,0x936,0x93a,0x34b,0x34b,0x34b,0x34b,0x32e,0x334,0x942,0x94a,0x951,0x4e2,0x34b,0x34b,0x959,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0xd30,0xd30,0xd48,0xd88,0xdc8,0xe04,0xe44,0xe84,0xebc,0xefc,0xf3c,0xf7c,0xfbc,0xffc,0x103c,0x107c,
+0x10bc,0x10fc,0x113c,0x117c,0x118c,0x11c0,0x11fc,0x123c,0x127c,0x12bc,0xd2c,0x12f0,0x1324,0x1364,0x1380,0x13b4,
+0x9e1,0xa11,0xa51,0xa90,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xac8,0x188,0x188,
+0x188,0x188,0x188,0x188,0x188,0x188,0x188,0xb08,0x188,0x188,0xb3d,0xb7c,0xbbc,0xbf6,0xc2d,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
@@ -174,246 +174,253 @@ static const uint16_t ucase_props_trieIndex[11720]={
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
 0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,0x188,
-0xc5c,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x656,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x935,0x346,0x346,0x346,0x938,0x346,0x346,0x346,
-0x346,0x940,0x946,0x94a,0x346,0x346,0x94e,0x952,0x958,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x960,0x964,0x346,0x346,0x346,0x346,0x346,0x96c,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x974,0x978,0x980,0x984,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x530,0x989,0x990,0x59b,0x59a,0x994,0x346,0x346,0x99c,0x9a3,0x346,0x9a9,0x59a,0x9ae,0x9b6,
-0x346,0x346,0x9bb,0x346,0x346,0x346,0x346,0x329,0x9c3,0x59a,0x531,0x9cb,0x9d2,0x346,0x346,0x346,
-0x346,0x346,0x989,0x9da,0x346,0x346,0x9de,0x9e6,0x346,0x346,0x346,0x346,0x346,0x346,0x9ea,0x9f2,
-0x346,0x346,0x9fa,0x4a1,0x346,0x346,0xa02,0x346,0x346,0xa08,0xa10,0x346,0x346,0x346,0x346,0x346,
-0x346,0xa18,0xa20,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa28,0xa2c,0xa34,0x346,
-0xa3b,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa42,0x346,0x346,
-0x8fd,0xa4a,0x346,0x346,0x346,0xa50,0xa58,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa5c,0x346,
-0xa62,0x56d,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0xa68,0x346,0x346,0x59a,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa70,0x56d,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa78,0xa80,0xa86,0x346,0x346,0x346,0x346,0xa8e,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xa96,0xa9e,0xaa3,0xaa9,
-0xab1,0xab9,0xac1,0xa9a,0xac9,0xad1,0xad9,0xae0,0xa9b,0xa96,0xa9e,0xa99,0xaa9,0xa9c,0xa97,0xae8,
-0xa9a,0xaf0,0xaf8,0xb00,0xb07,0xaf3,0xafb,0xb03,0xb0a,0xaf6,0xb12,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x846,0xb1a,0x846,0xb21,0xb28,
-0xb30,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xb38,0xb40,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0xb44,0x346,0xb4c,0xb54,0xb5b,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0xa92,0xb63,0xb63,0xb69,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x99e,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x530,0x846,0x846,0x846,
-0x346,0x346,0x346,0x346,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0xa6c,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,
-0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0x346,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0,0,0,0,0,0,4,0,0,0,0,0,
-0,0,0,0,0,0,4,0,0,0,0,0,0,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x1a,0xba,0xfa,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x17a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0,0,0,4,0,4,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0xf009,0xf009,0x1f9,0xf029,0x299,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0x319,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,1,0,
-0,4,0,4,0,0,0,0,4,0x399,0,4,4,0,1,0,
-0,0,0,0,0x100a,0x100a,0x100a,0x100a,0x100a,0x3fa,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x47a,0x4ba,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x4f9,0xf009,0xf009,0xf009,0xf009,0xf009,0x639,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0x3c89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x6ba,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x6fa,0xffa9,0x73a,0x7f9,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,1,0x8a,0xff89,0x8a,
-0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x899,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xc38a,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x999,
-0x6189,0x690a,0x8a,0xff89,0x8a,0xff89,0x670a,0x8a,0xff89,0x668a,0x668a,0x8a,0xff89,1,0x278a,0x650a,
-0x658a,0x8a,0xff89,0x668a,0x678a,0x3089,0x698a,0x688a,0x8a,0xff89,0x5189,1,0x698a,0x6a8a,0x4109,0x6b0a,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x6d0a,0x8a,0xff89,0x6d0a,1,1,0x8a,0xff89,0x6d0a,0x8a,
-0xff89,0x6c8a,0x6c8a,0x8a,0xff89,0x8a,0xff89,0x6d8a,0x8a,0xff89,1,0,0x8a,0xff89,1,0x1c09,
-0,0,0,0,0x9fa,0xa5b,0xad9,0xb3a,0xb9b,0xc19,0xc7a,0xcdb,0xd59,0x8a,0xff89,0x8a,
-0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xd889,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0xdb9,0xeba,0xf1b,0xf99,0x8a,0xff89,0xcf8a,0xe40a,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xbf0a,1,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,1,1,1,1,
-1,1,0xffa,0x8a,0xff89,0xae8a,0x103a,0x1079,0x10b9,0x8a,0xff89,0x9e8a,0x228a,0x238a,0x8a,0xff89,
-0x8a,0xffa9,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x10f9,0x1139,0x1179,0x9709,0x9909,1,0x9989,0x9989,
-1,0x9b09,1,0x9a89,0x11b9,1,1,1,0x9989,0x11f9,1,0x9889,1,0x1239,0x1279,1,
-0x97a9,0x9689,0x12b9,0x12f9,0x1339,1,1,0x9689,1,0x1379,0x9589,1,1,0x9509,1,1,
-1,1,1,1,1,0x13b9,1,1,0x9309,1,1,0x9309,1,1,1,0x13f9,
-0x9309,0xdd89,0x9389,0x9389,0xdc89,1,1,1,1,1,0x9289,1,0,1,1,1,
-1,1,1,1,1,0x1439,0x1479,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,5,5,0x25,5,5,5,5,5,
-5,4,4,4,0xc,4,0xc,4,5,5,4,4,4,4,4,4,
+0xc6d,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x960,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x968,0x34b,0x34b,0x34b,0x96b,0x34b,0x34b,0x34b,
+0x34b,0x973,0x979,0x97d,0x34b,0x34b,0x981,0x985,0x98b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x993,0x997,0x34b,0x34b,0x34b,0x34b,0x34b,0x99f,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x9a7,0x9ab,0x9b3,0x9b7,0x34b,0x9be,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x9c5,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x536,0x9ca,0x9d1,0x5b4,0x5b3,0x9d5,0x533,0x34b,0x9dd,0x9e4,0x34b,0x9ea,0x5b3,0x9ef,0x9f7,
+0x34b,0x34b,0x9fc,0x34b,0x34b,0x34b,0x34b,0x32e,0xa04,0x5b3,0x5b5,0xa0c,0xa13,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x9ca,0xa1b,0x34b,0x34b,0xa23,0xa2b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xa2f,0xa37,
+0x34b,0x34b,0xa3f,0x4a6,0x34b,0x34b,0xa47,0x34b,0x34b,0xa4d,0xa55,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0xa5a,0x34b,0x34b,0x34b,0xa62,0xa6a,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0xa72,0xa76,0xa7e,0x34b,0xa85,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0xa8c,0x34b,0x34b,0x929,0xa94,0x34b,0x34b,0x34b,0xa9a,0xaa2,0x34b,0xaa6,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xaac,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xab2,
+0x34b,0xab8,0x573,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xa62,0xa6a,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0xabe,0x34b,0x34b,0x5b3,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xac6,0x573,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xace,0xad6,0xadc,0x34b,0x34b,0x34b,0x34b,0xae4,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xaec,0xaf4,0xaf9,
+0xaff,0xb07,0xb0f,0xb17,0xaf0,0xb1f,0xb27,0xb2f,0xb36,0xaf1,0xaec,0xaf4,0xaef,0xaff,0xaf2,0xaed,
+0xb3e,0xaf0,0xb46,0xb4e,0xb56,0xb5d,0xb49,0xb51,0xb59,0xb60,0xb4c,0xb68,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x870,0xb70,0x870,0xb77,
+0xb7e,0xb86,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xb8e,0xb96,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xb9a,0x34b,0xba2,0xbaa,
+0xbb1,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xae8,0xbb9,0xbb9,0xbbf,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x9df,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x536,0x870,0x870,
+0x870,0x34b,0x34b,0x34b,0x34b,0x870,0x870,0x870,0x870,0x870,0x870,0x870,0xac2,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
+0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x32b,0x32b,0x32b,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,4,0,0,0,0,0,0,4,0,
+0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,
+0,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0xa,0x5a,0x7a,0x1012,0x1012,0x1012,0x1012,
+0x1012,0x1012,0x1012,0xba,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0,0,0,4,0,
+4,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf9,0xf031,0x149,0xf011,0xf011,0xf011,0xf011,
+0xf011,0xf011,0xf011,0x189,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,0,1,0,0,4,0,4,0,0,0,0,4,0x1c9,0,4,
+4,0,1,0,0,0,0,0,0x1012,0x1012,0x1012,0x1012,0x1012,0x1fa,0x1012,0x1012,
+0x1012,0x1012,0x1012,0x1012,0x5a,0x5a,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0,
+0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x239,0xf011,0xf011,0xf011,0xf011,0xf011,0x2d9,0xf011,0xf011,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0x3c91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x31a,0xff91,0x92,0xff91,0x92,0xff91,0x31a,0xffb1,0x33a,0x389,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x3d9,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0xc392,0x92,0xff91,0x92,
+0xff91,0x92,0xff91,0x459,0x6191,0x6912,0x92,0xff91,0x92,0xff91,0x6712,0x92,0xff91,0x6692,0x6692,0x92,
+0xff91,1,0x2792,0x6512,0x6592,0x92,0xff91,0x6692,0x6792,0x3091,0x6992,0x6892,0x92,0xff91,0x5191,1,
+0x6992,0x6a92,0x4111,0x6b12,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x6d12,0x92,0xff91,0x6d12,1,1,
+0x92,0xff91,0x6d12,0x92,0xff91,0x6c92,0x6c92,0x92,0xff91,0x92,0xff91,0x6d92,0x92,0xff91,1,0,
+0x92,0xff91,1,0x1c11,0,0,0,0,0x48a,0x4bb,0x4f9,0x52a,0x55b,0x599,0x5ca,0x5fb,
+0x639,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,
+0xff91,0xd891,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x669,0x6ea,0x71b,0x759,0x92,0xff91,0xcf92,0xe412,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0xbf12,1,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+1,1,1,1,1,1,0x78a,0x92,0xff91,0xae92,0x7aa,0x7c9,0x7c9,0x92,0xff91,0x9e92,
+0x2292,0x2392,0x92,0xff91,0x92,0xffb1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x7e9,0x809,0x829,0x9711,
+0x9911,1,0x9991,0x9991,1,0x9b11,1,0x9a91,0x849,1,1,1,0x9991,0x869,1,0x9891,
+1,0x889,0x8a9,1,0x97b1,0x9691,0x8a9,0x8c9,0x8e9,1,1,0x9691,1,0x909,0x9591,1,
+1,0x9511,1,1,1,1,1,1,1,0x929,1,1,0x9311,1,1,0x9311,
+1,1,1,0x949,0x9311,0xdd91,0x9391,0x9391,0xdc91,1,1,1,1,1,0x9291,1,
+0,1,1,1,1,1,1,1,1,0x969,0x989,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,5,5,0x25,5,
+5,5,5,5,5,4,4,4,0x14,4,0x14,4,5,5,4,4,
 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,5,5,5,5,5,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,0x4c,0x4c,0x44,0x44,0x44,0x44,0x44,0x14bc,
-0x4c,0x44,0x4c,0x44,0x4c,0x44,0x44,0x44,0x44,0x44,0x44,0x4c,0x44,0x64,0x64,0x64,
-0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,
-0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x6c,0x64,0x64,0x64,0x64,0x64,0x64,
-0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x4c,0x44,0x44,0x14dd,0x44,0x64,
-0x64,0x64,0x44,0x44,0x44,0x64,0x64,4,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0x44,
-0x64,0x64,0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x8a,0xff89,0x8a,0xff89,4,4,0x8a,0xff89,
-0,0,5,0x4109,0x4109,0x4109,0,0x3a0a,0,0,0,0,4,4,0x130a,4,
-0x128a,0x128a,0x128a,0,0x200a,0,0x1f8a,0x1f8a,0x1579,0x100a,0x171a,0x100a,0x100a,0x179a,0x100a,0x100a,
-0x181a,0x18ba,0x195a,0x100a,0x19da,0x100a,0x100a,0x100a,0x1a5a,0x1ada,0,0x1b5a,0x100a,0x100a,0x1bda,0x100a,
-0x100a,0x1c5a,0x100a,0x100a,0xed09,0xed89,0xed89,0xed89,0x1cd9,0xf009,0x1e79,0xf009,0xf009,0x1ef9,0xf009,0xf009,
-0x1f79,0x2019,0x20b9,0xf009,0x2139,0xf009,0xf009,0xf009,0x21b9,0x2239,0x22b9,0x2319,0xf009,0xf009,0x2399,0xf009,
-0xf009,0x2419,0xf009,0xf009,0xe009,0xe089,0xe089,0x40a,0x2499,0x24f9,2,2,2,0x2599,0x25f9,0xfc09,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x2659,0x26b9,0x389,0xc629,0x271a,0x27b9,0,0x8a,
-0xff89,0xfc8a,0x8a,0xff89,1,0xbf0a,0xbf0a,0xbf0a,0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,
-0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,0x280a,0x100a,0x100a,0x281a,0x100a,0x289a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x291a,0x100a,0x100a,0x299a,0x2a1a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x2aba,0x100a,0x100a,0x100a,0x100a,0x100a,0xf009,0xf009,0x2b39,0xf009,0x2bb9,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0x2c39,0xf009,0xf009,0x2cb9,0x2d39,0xf009,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0x2dd9,0xf009,0xf009,0xf009,0xf009,0xf009,0xd809,0xd809,0xd809,0xd809,0xd809,0xd809,0xd829,0xd809,
-0xd829,0xd809,0xd809,0xd809,0xd809,0xd809,0xd809,0xd809,0x8a,0xff89,0x2e5a,0x2ed9,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0,0x44,0x44,0x44,0x44,0x44,
-4,4,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x78a,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,
-0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xf889,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,
-0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,
-0x180a,0x180a,0x180a,0,0,4,0,0,0,0,0,0,0,0xe809,0xe809,0xe809,
-0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,
-0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0x2f59,
-0,0,0,0,0,0,0,0,0,0x64,0x44,0x44,0x44,0x44,0x64,0x44,
-0x44,0x44,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0x64,0x64,
-0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,
-0x64,0x64,0x64,0x64,0x64,0x64,0,0x64,0,0x64,0x64,0,0x44,0x64,0,0x64,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,
+5,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,4,4,4,4,4,0x54,0x54,0x44,0x44,
+0x44,0x44,0x44,0x9ac,0x54,0x44,0x54,0x44,0x54,0x44,0x44,0x44,0x44,0x44,0x44,0x54,
+0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,
+0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x74,0x64,0x64,
+0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x54,0x44,
+0x44,0x9bd,0x44,0x64,0x64,0x64,0x44,0x44,0x44,0x64,0x64,4,0x44,0x44,0x44,0x64,
+0x64,0x64,0x64,0x44,0x64,0x64,0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x44,
+0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x92,0xff91,0x92,0xff91,
+4,4,0x92,0xff91,0,0,5,0x4111,0x4111,0x4111,0,0x3a12,0,0,0,0,
+4,4,0x1312,4,0x1292,0x1292,0x1292,0,0x2012,0,0x1f92,0x1f92,0xa09,0x1012,0xada,0x1012,
+0x1012,0xb1a,0x1012,0x1012,0xb5a,0xbaa,0xbfa,0x1012,0xc3a,0x1012,0x1012,0x1012,0xc7a,0xcba,0,0xcfa,
+0x1012,0x1012,0xd3a,0x1012,0x1012,0xd7a,0x1012,0x1012,0xed11,0xed91,0xed91,0xed91,0xdb9,0xf011,0xe89,0xf011,
+0xf011,0xec9,0xf011,0xf011,0xf09,0xf59,0xfa9,0xf011,0xfe9,0xf011,0xf011,0xf011,0x1029,0x1069,0x10a9,0x10d9,
+0xf011,0xf011,0x1119,0xf011,0xf011,0x1159,0xf011,0xf011,0xe011,0xe091,0xe091,0x412,0x1199,0x11c9,2,2,
+2,0x1219,0x1249,0xfc11,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x1279,0x12a9,0x391,0xc631,
+0x12da,0x1329,0,0x92,0xff91,0xfc92,0x92,0xff91,1,0xbf12,0xbf12,0xbf12,0x2812,0x2812,0x2812,0x2812,
+0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x2812,0x1012,0x1012,0x135a,0x1012,
+0x139a,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x13da,0x1012,0x1012,0x141a,0x145a,0x1012,
+0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x14aa,0x1012,0x1012,0x1012,0x1012,0x1012,0xf011,0xf011,0x14e9,0xf011,
+0x1529,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0x1569,0xf011,0xf011,0x15a9,0x15e9,0xf011,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0x1639,0xf011,0xf011,0xf011,0xf011,0xf011,0xd811,0xd811,0xd811,0xd811,
+0xd811,0xd811,0xd831,0xd811,0xd831,0xd811,0xd811,0xd811,0xd811,0xd811,0xd811,0xd811,0x92,0xff91,0x167a,0x16b9,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0x44,
+0x44,0x44,0x44,0x44,4,4,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x792,0x92,0xff91,0x92,
+0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0xf891,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0x1812,0x1812,0x1812,
+0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
+0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0,0,4,0,0,0,0,0,0,
+1,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
+0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
+0xe811,0xe811,0xe811,0x16f9,1,0,0,0,0,0,0,0,0,0x64,0x44,0x44,
+0x44,0x44,0x64,0x44,0x44,0x44,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x64,
+0x64,0x64,0x64,0x64,0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x44,0x64,0x64,0x64,0x64,
+0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0x64,0,0x64,0x64,0,
+0x44,0x64,0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,
+4,4,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,
+0x44,0x44,0x44,0x44,0x64,0x64,0x64,0,4,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,4,4,4,0,0,
-0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x64,0x64,0x64,0,4,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x44,
+0x44,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x64,0x44,0x44,0x64,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,
-0,0,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x64,0x64,0x44,
-0x44,0x44,0x44,0x44,0x64,0x44,0x44,0x64,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x64,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,4,0,0x44,
+0x44,0x44,0x44,0x64,0x44,4,4,0x44,0x44,0,0x64,0x44,0x44,0x64,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,4,0,0x44,0x44,0x44,0x44,0x64,
-0x44,4,4,0x44,0x44,0,0x64,0x44,0x44,0x64,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
-0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,4,0,0x64,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x44,0x64,0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x64,0x44,0x64,0x64,0x44,0x64,0x44,
-0x44,0x44,0x64,0x44,0x64,0x44,0x64,0x44,0x64,0x44,0x44,0,0,0,0,0,
+0,0,0,0,0x44,0x64,0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x64,0x44,0x64,
+0x64,0x44,0x64,0x44,0x44,0x44,0x64,0x44,0x64,0x44,0x64,0x44,0x64,0x44,0x44,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,4,4,4,4,4,4,4,4,4,4,4,0,0,0,
+0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,
+4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x44,
+0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x44,4,4,0,0,0,0,4,0,
+0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,4,0x44,
+0x44,0x44,0x44,0x44,4,0x44,0x44,0x44,4,0x44,0x44,0x44,0x44,0x44,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x64,0x44,4,4,0,0,0,0,4,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0x64,0x64,0x64,0,0,0,0,
+0x44,0x44,4,0x64,0x44,0x44,0x64,0x44,0x44,0x64,0x44,0x44,0x44,0x64,0x64,0x64,
+0x64,0x64,0x64,0x44,0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x44,0x44,0x44,0x44,0x44,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0x44,0x44,0x44,0x44,4,0x44,0x44,0x44,0x44,0x44,4,0x44,0x44,0x44,
-4,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
+4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0x64,0x64,0x64,0,0,0,0,0x44,0x44,4,0x64,0x44,0x44,0x64,0x44,
-0x44,0x64,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x44,0x64,0x44,
-0x44,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,4,4,4,0,0,0,0,0,
+0,0,4,0,0x64,0,0,0,0,4,4,4,4,4,4,4,
+4,0,0,0,0,0x64,0,0,0,0x44,0x64,0x44,0x44,4,4,4,
+0,0,0,0,0,0,0,0,0,0,4,4,0,0,0,0,
+0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,0,0x64,0,0,0,
-0,4,4,4,4,4,4,4,4,0,0,0,0,0x64,0,0,
-0,0x44,0x64,0x44,0x44,4,4,4,0,0,0,0,0,0,0,0,
-0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x64,0,0,0,0,4,4,4,
+4,0,0,0,0,0,0,0,0,0x64,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x64,0,0,0,0,4,4,4,4,0,0,0,0,0,0,0,
-0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,4,4,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x44,0,0,4,4,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,4,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,0,
+0,0,0,4,4,0,0,4,4,0x64,0,0,0,4,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,4,0,0,0,0,4,4,0,0,4,
-4,0x64,0,0,0,4,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,0,0,0,4,0,0,
-0,0,0,0,0,0,0,0,0,4,4,4,4,4,0,4,
-4,0,0,0,0,0x64,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,4,0,0,0,0,
+4,4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,
+0,4,4,4,4,4,0,4,4,0,0,0,0,0x64,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,4,4,4,4,4,4,0,0,0,0,0,0,0,0,
+0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,4,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x64,0,0,4,0,4,4,4,4,0,0,0,
-0,0,0,0,0,0x64,0,0,0,0,0,0,0,0,4,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,0,4,
+0,4,4,4,4,0,0,0,0,0,0,0,0,0x64,0,0,
+0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,
+0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
-0,0,0,0,0,0,0,0,0,0x64,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
-0,0,4,4,4,0,4,4,4,0x64,0,0,0,0,0,0,
-0,0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,4,0,
-0,0,0,0,4,0x64,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,0,0,0,0,0,0,
+0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0x64,0x64,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x64,0,0,0,0,0,
-0,0,4,4,4,0,4,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,4,0,0,4,4,4,4,
-0x64,0x64,0x64,0,0,0,0,0,0,0,4,4,0x64,0x64,0x64,0x64,
-4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,4,0,0,4,4,4,4,0x64,0x64,0,4,
-4,0,0,0,0,0,0,0,0,0,4,0,0x64,0x64,0x64,0x64,
-4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x64,0x64,0,0,
+4,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0x64,0,0x64,0,0x64,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0x64,4,
-0x64,4,4,4,4,4,0x64,0x64,0x64,0x64,4,0,0x64,4,0x44,0x44,
-0x64,0,0x44,0x44,0,0,0,0,0,4,4,4,4,4,4,4,
-4,4,4,4,0,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,0,0,0,0,0,0,0,0,0,0x64,0,
+4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,0,0,0,0,0,4,4,4,0,4,4,4,0x64,0,0,
+0,0,0,0,0,0x64,0x64,0,0,0,0,0,0,0,0,0,
+0,0,4,0,0,0,0,0,4,0x64,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,4,4,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,4,4,4,4,0,4,4,
-4,4,4,0x64,0,0x64,0x64,0,0,4,4,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,
+0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,
+0,0,0,0,0,0,4,4,4,0,4,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,
+4,4,4,4,0x64,0x64,0x64,0,0,0,0,0,0,0,4,4,
+0x64,0x64,0x64,0x64,4,4,4,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,4,0,0,4,4,4,4,
+0x64,0x64,0,4,4,0,0,0,0,0,0,0,0,0,4,0,
+0x64,0x64,0x64,0x64,4,4,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,4,4,0,0,0,0,4,4,4,0,0,0,
+0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0x64,0,0x64,0,0x64,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0x64,0x64,4,0x64,4,4,4,4,4,0x64,0x64,0x64,0x64,4,0,
+0x64,4,0x44,0x44,0x64,0,0x44,0x44,0,0,0,0,0,4,4,4,
+4,4,4,4,4,4,4,4,0,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,
+0,0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,
-4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,
-0,4,4,0,0,0,0,0,0,0x64,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,4,0,0,0x305a,0x309a,0x30da,0x311a,
-0x315a,0x319a,0x31da,0x321a,0x325a,0x329a,0x32da,0x331a,0x335a,0x339a,0x33da,0x341a,0x345a,0x349a,0x34da,0x351a,
-0x355a,0x359a,0x35da,0x361a,0x365a,0x369a,0x36da,0x371a,0x375a,0x379a,0x37da,0x381a,0x385a,0x389a,0x38da,0x391a,
-0x395a,0x399a,0,0x39da,0,0,0,0,0,0x3a1a,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x525a,0x52ba,0x531a,0x537a,
-0x53da,0x543a,0x549a,0x54fa,0x555a,0x55ba,0x561a,0x567a,0x56da,0x573a,0x579a,0x57fa,0x585a,0x58ba,0x591a,0x597a,
-0x59da,0x5a3a,0,0,0x5a99,0x5af9,0x5b59,0x5bb9,0x5c19,0x5c79,0,0,0x3a5a,0x3aba,0x3b1a,0x3b7a,
-0x3bda,0x3c3a,0x3c9a,0x3cfa,0x3d5a,0x3dba,0x3e1a,0x3e7a,0x3eda,0x3f3a,0x3f9a,0x3ffa,0x405a,0x40ba,0x411a,0x417a,
-0x41da,0x423a,0x429a,0x42fa,0x435a,0x43ba,0x441a,0x447a,0x44da,0x453a,0x459a,0x45fa,0x465a,0x46ba,0x471a,0x477a,
-0x47da,0x483a,0x489a,0x48fa,0x495a,0x49ba,0x4a1a,0x4a7a,0x4ada,0x4b3a,0x4b9a,0x4bfa,0x4c5a,0x4cba,0x4d1a,0x4d7a,
-0x4dda,0x4e3a,0x4e9a,0x4efa,0x4f5a,0x4fba,0x501a,0x507a,0x50da,0x513a,0x519a,0x51fa,0,0,0,0,
+4,0,4,4,4,4,4,0x64,0,0x64,0x64,0,0,4,4,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,0,0,0,0,4,4,
+4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0,
+0,0,4,0,0,4,4,0,0,0,0,0,0,0x64,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,
+0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,
+0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,0x177a,
+0x177a,0x177a,0,0x177a,0,0,0,0,0,0x177a,0,0,0x1799,0x17c9,0x17f9,0x1829,
+0x1859,0x1889,0x18b9,0x18e9,0x1919,0x1949,0x1979,0x19a9,0x19d9,0x1a09,0x1a39,0x1a69,0x1a99,0x1ac9,0x1af9,0x1b29,
+0x1b59,0x1b89,0x1bb9,0x1be9,0x1c19,0x1c49,0x1c79,0x1ca9,0x1cd9,0x1d09,0x1d39,0x1d69,0x1d99,0x1dc9,0x1df9,0x1e29,
+0x1e59,0x1e89,0x1eb9,0x1ee9,0x1f19,0x1f49,0x1f79,0,4,0x1fa9,0x1fd9,0x2009,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x203a,0x203a,0x203a,0x203a,
+0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x205a,0x205a,0x205a,0x205a,
+0x205a,0x205a,0,0,0x2079,0x20a9,0x20d9,0x2109,0x2139,0x2169,0,0,0x203a,0x203a,0x203a,0x203a,
+0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,
+0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0x203a,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,
 0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,4,4,0,4,4,4,4,4,
@@ -423,145 +430,149 @@ static const uint16_t ucase_props_trieIndex[11720]={
 4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0x64,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,0,
-0,0,0,4,4,0,0,0,0,0,0,0,0,0,4,0,
-0,0,0,0,0,0x64,0x44,0x64,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x44,
-0x64,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,0,4,4,4,4,
-4,4,4,0,0x64,0,4,0,0,4,4,4,4,4,4,4,
-4,0,0,0,0,0,0,4,4,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x44,0,0,0x64,0,0,0,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,
-0x44,0x64,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x64,0,4,4,4,4,4,0,
-4,0,0,0,0,0,4,0,0x60,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x44,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,
-4,4,0,0,4,4,0x60,0x64,4,4,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,
-4,4,0,0,0,4,0,4,4,4,0x60,0x60,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,
-0,0,4,0x64,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,
-4,4,0,0,0x5cd9,0x5d39,0x5d99,0x5df9,0x5e59,0x5ef9,0x5f99,0x5ff9,0x6059,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x44,0x44,0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,
-0x64,0x64,0x64,0x64,0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0,0,
-0,0x64,0,0,0,0,0,0,0x44,0,0,0,0x44,0x44,0,0,
-0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
+0,0,0,0,0,4,4,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,4,0,0,0,0,4,
+4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,
+0,0x64,0x44,0x64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0x44,0x64,0,0,4,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,4,0,4,4,4,4,4,4,4,0,
+0x64,0,4,0,0,4,4,4,4,4,4,4,4,0,0,0,
+0,0,0,4,4,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0x64,
+0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
+0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x64,4,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x64,0,4,4,4,4,4,0,4,0,0,0,
+0,0,4,0,0x60,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0x44,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,4,4,4,4,0,0,
+4,4,0x60,0x64,4,4,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x64,0,4,4,0,0,
+0,4,0,4,4,4,0x60,0x60,0,0,0,0,0,0,0,0,
+0,0,0,0,4,4,4,4,4,4,4,4,0,0,4,0x64,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,4,4,4,4,0,0,
+0x2199,0x21c9,0x21f9,0x2229,0x2259,0x22a9,0x22f9,0x2329,0x2359,0,0,0,0,0,0,0,
+0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,
+0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0x238a,0,0,0x238a,0x238a,0x238a,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x44,0x44,0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0x64,0x64,0x64,0x64,
+0x44,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0,0,0,0x64,0,0,
+0,0,0,0,0x44,0,0,0,0x44,0x44,0,0,0,0,0,0,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,0x25,5,5,5,5,5,5,5,5,1,
-1,1,1,1,1,1,1,1,1,1,1,1,5,0x60b9,1,1,
-1,0x60f9,1,1,5,5,5,5,0x25,5,5,5,0x25,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,0x21,1,1,1,1,5,
-5,5,5,5,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0,0x44,
-0x64,0x64,0x44,0x64,0x44,0x44,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x44,
-0x44,0x64,0x64,0x64,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xffa9,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x613a,0x61b9,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x6239,0x6339,0x6439,0x6539,0x6639,0x6739,1,1,0x679a,1,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xffa9,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x409,0x409,0x409,0x409,0x409,0x409,0x409,0x409,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,
-0x409,0x409,0x409,0x409,0x409,0x409,0,0,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0,0,
-0x409,0x409,0x409,0x409,0x409,0x409,0x409,0x409,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,
-0x409,0x409,0x409,0x409,0x409,0x409,0x409,0x409,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,
-0x409,0x409,0x409,0x409,0x409,0x409,0,0,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0,0,
-0x6839,0x409,0x6939,0x409,0x6a99,0x409,0x6bf9,0x409,0,0xfc0a,0,0xfc0a,0,0xfc0a,0,0xfc0a,
-0x409,0x409,0x409,0x409,0x409,0x409,0x409,0x409,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,0xfc0a,
-0x2509,0x2509,0x2b09,0x2b09,0x2b09,0x2b09,0x3209,0x3209,0x4009,0x4009,0x3809,0x3809,0x3f09,0x3f09,0,0,
-0x6d59,0x6e39,0x6f19,0x6ff9,0x70d9,0x71b9,0x7299,0x7379,0x745b,0x753b,0x761b,0x76fb,0x77db,0x78bb,0x799b,0x7a7b,
-0x7b59,0x7c39,0x7d19,0x7df9,0x7ed9,0x7fb9,0x8099,0x8179,0x825b,0x833b,0x841b,0x84fb,0x85db,0x86bb,0x879b,0x887b,
-0x8959,0x8a39,0x8b19,0x8bf9,0x8cd9,0x8db9,0x8e99,0x8f79,0x905b,0x913b,0x921b,0x92fb,0x93db,0x94bb,0x959b,0x967b,
-0x409,0x409,0x9759,0x9859,0x9939,0,0x9a39,0x9b39,0xfc0a,0xfc0a,0xdb0a,0xdb0a,0x9c9b,4,0x9d79,4,
-4,4,0x9e19,0x9f19,0x9ff9,0,0xa0f9,0xa1f9,0xd50a,0xd50a,0xd50a,0xd50a,0xa35b,4,4,4,
-0x409,0x409,0xa439,0xa599,0,0,0xa739,0xa839,0xfc0a,0xfc0a,0xce0a,0xce0a,0,4,4,4,
-0x409,0x409,0xa999,0xaaf9,0xac99,0x389,0xad99,0xae99,0xfc0a,0xfc0a,0xc80a,0xc80a,0xfc8a,4,4,4,
-0,0,0xaff9,0xb0f9,0xb1d9,0,0xb2d9,0xb3d9,0xc00a,0xc00a,0xc10a,0xc10a,0xb53b,4,4,0,
-0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,
-0,0,0,0,0,0,0,0,4,4,0,0,0,0,0,0,
-4,0,0,4,0,0,4,4,4,4,4,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,
-4,0,4,4,4,4,4,4,4,4,4,4,0,0x25,0,0,
-0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x64,0x64,
-0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x44,0x44,4,4,4,4,0x44,4,4,
-4,0x64,0x64,0x44,0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,
-0,0,0,2,0,0,1,2,2,2,1,1,2,2,2,1,
-0,2,0,0,0,2,2,2,2,2,0,0,0,0,0,0,
-2,0,0xb61a,0,2,0,0xb69a,0xb71a,2,2,0,1,2,2,0xe0a,2,
-1,0,0,0,0,1,0,0,1,1,2,2,0,0,0,0,
-0,2,1,1,0x21,0x21,0,0,0,0,0xf209,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x80a,0x80a,0x80a,0x80a,
-0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0x80a,0xf809,0xf809,0xf809,0xf809,
-0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0xf809,0,0,0,0x8a,
-0xff89,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xd0a,0xd0a,
-0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,0xd0a,
-0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,0xf309,
-0xf309,0xf309,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,
-0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,
-0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0x180a,0,0xe809,0xe809,0xe809,0xe809,
-0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,
-0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0xe809,0,0x8a,0xff89,0xb79a,0xb7da,
-0xb81a,0xb859,0xb899,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xb8da,0xb91a,0xb95a,0xb99a,1,0x8a,0xff89,
-1,0x8a,0xff89,1,1,1,1,1,0x25,5,0xb9da,0xba1a,0x8a,0xff89,0x8a,0xff89,
-1,0,0,0,0,0,0,0x8a,0xff89,0x8a,0xff89,0x44,0x44,0x44,0x8a,0xff89,
-0,0,0,0,0,0,0,0,0,0,0,0,0xba59,0xba99,0xbad9,0xbb19,
-0xbb59,0xbb99,0xbbd9,0xbc19,0xbc59,0xbc99,0xbcd9,0xbd19,0xbd59,0xbd99,0xbdd9,0xbe19,0xbe59,0xbe99,0xbed9,0xbf19,
-0xbf59,0xbf99,0xbfd9,0xc019,0xc059,0xc099,0xc0d9,0xc119,0xc159,0xc199,0xc1d9,0xc219,0xc259,0xc299,0xc2d9,0xc319,
-0xc359,0xc399,0,0xc3d9,0,0,0,0,0,0xc419,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,
+5,5,0x25,5,5,5,5,5,5,5,5,1,1,1,1,1,
+1,1,1,1,1,1,1,1,5,0x23a9,1,1,1,0x23c9,1,1,
+5,5,5,5,0x25,5,5,5,0x25,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,0x21,1,1,1,1,5,5,5,5,5,
 0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
+0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0x64,0x64,0,0x44,0x64,0x64,0x44,0x64,
+0x44,0x44,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0x44,0x44,0x64,0x64,0x64,
+0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xffb1,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x23ea,0x2429,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x2469,0x24e9,0x2569,0x25e9,0x2669,0x26e9,1,1,0x271a,1,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xffb1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x411,0x411,0x411,0x411,
+0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
+0x411,0x411,0,0,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0,0,0x411,0x411,0x411,0x411,
+0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
+0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x411,0x411,0x411,0x411,
+0x411,0x411,0,0,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0,0,0x2769,0x411,0x27e9,0x411,
+0x2899,0x411,0x2949,0x411,0,0xfc12,0,0xfc12,0,0xfc12,0,0xfc12,0x411,0x411,0x411,0x411,
+0x411,0x411,0x411,0x411,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0xfc12,0x2511,0x2511,0x2b11,0x2b11,
+0x2b11,0x2b11,0x3211,0x3211,0x4011,0x4011,0x3811,0x3811,0x3f11,0x3f11,0,0,0x29f9,0x2a69,0x2ad9,0x2b49,
+0x2bb9,0x2c29,0x2c99,0x2d09,0x2d7b,0x2deb,0x2e5b,0x2ecb,0x2f3b,0x2fab,0x301b,0x308b,0x30f9,0x3169,0x31d9,0x3249,
+0x32b9,0x3329,0x3399,0x3409,0x347b,0x34eb,0x355b,0x35cb,0x363b,0x36ab,0x371b,0x378b,0x37f9,0x3869,0x38d9,0x3949,
+0x39b9,0x3a29,0x3a99,0x3b09,0x3b7b,0x3beb,0x3c5b,0x3ccb,0x3d3b,0x3dab,0x3e1b,0x3e8b,0x411,0x411,0x3ef9,0x3f79,
+0x3fe9,0,0x4069,0x40e9,0xfc12,0xfc12,0xdb12,0xdb12,0x419b,4,0x4209,4,4,4,0x4259,0x42d9,
+0x4349,0,0x43c9,0x4449,0xd512,0xd512,0xd512,0xd512,0x44fb,4,4,4,0x411,0x411,0x4569,0x4619,
+0,0,0x46e9,0x4769,0xfc12,0xfc12,0xce12,0xce12,0,4,4,4,0x411,0x411,0x4819,0x48c9,
+0x4999,0x391,0x4a19,0x4a99,0xfc12,0xfc12,0xc812,0xc812,0xfc92,4,4,4,0,0,0x4b49,0x4bc9,
+0x4c39,0,0x4cb9,0x4d39,0xc012,0xc012,0xc112,0xc112,0x4deb,4,4,0,0,0,0,0,
+0,0,0,0,0,0,0,4,4,4,4,4,0,0,0,0,
+0,0,0,0,4,4,0,0,0,0,0,0,4,0,0,4,
+0,0,4,4,4,4,4,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,4,4,4,0,4,4,
+4,4,4,4,4,4,4,4,0,0x25,0,0,0,0,0,0,
+0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x44,0x44,0x64,0x64,0x44,0x44,0x44,0x44,
+0x64,0x64,0x64,0x44,0x44,4,4,4,4,0x44,4,4,4,0x64,0x64,0x44,
+0x64,0x44,0x64,0x64,0x64,0x64,0x64,0x64,0x44,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,2,
+0,0,1,2,2,2,1,1,2,2,2,1,0,2,0,0,
+0,2,2,2,2,2,0,0,0,0,0,0,2,0,0x4e5a,0,
+2,0,0x4e9a,0x4eda,2,2,0,1,2,2,0xe12,2,1,0,0,0,
+0,1,0,0,1,1,2,2,0,0,0,0,0,2,1,1,
+0x21,0x21,0,0,0,0,0xf211,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x812,0x812,0x812,0x812,0x812,0x812,0x812,0x812,
+0x812,0x812,0x812,0x812,0x812,0x812,0x812,0x812,0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,
+0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,0xf811,0,0,0,0x92,0xff91,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,
+0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xd12,0xf311,0xf311,0xf311,0xf311,
+0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0xf311,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
+0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
+0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
+0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,
+0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0xe811,0,0x92,0xff91,0x4f1a,0x4f3a,0x4f5a,0x4f79,0x4f99,0x92,
+0xff91,0x92,0xff91,0x92,0xff91,0x4fba,0x4fda,0x4ffa,0x501a,1,0x92,0xff91,1,0x92,0xff91,1,
+1,1,1,1,0x25,5,0x503a,0x503a,0x92,0xff91,0x92,0xff91,1,0,0,0,
+0,0,0,0x92,0xff91,0x92,0xff91,0x44,0x44,0x44,0x92,0xff91,0,0,0,0,
+0,0,0,0,0,0,0,0,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,
+0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,
+0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0x5059,0,0x5059,0,0,0,0,
+0,0x5059,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0x64,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
 0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0,0,0,0,0,0,0,0,0,0,0x64,0x64,0x64,0x64,0x60,0x60,
-0,4,4,4,4,4,0,0,0,0,0,4,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0x64,0x64,4,4,4,4,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,0,0,0,0,0,
+0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,
+0,0,0x64,0x64,0x64,0x64,0x60,0x60,0,4,4,4,4,4,0,0,
+0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0x64,4,
+4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xc45a,0xc4d9,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0,0x44,4,4,4,0,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0,4,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,5,5,0x44,0x44,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x44,0x44,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,
+4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x507a,0x50b9,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0x44,
+4,4,4,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,4,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,5,5,0x44,0x44,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x44,0x44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,1,1,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,5,1,1,1,
-1,1,1,1,1,0x8a,0xff89,0x8a,0xff89,0xc55a,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,
-0x8a,0xff89,0x8a,0xff89,4,4,4,0x8a,0xff89,0xc59a,1,0,0x8a,0xff89,0x8a,0xff89,
-1,1,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0x8a,0xff89,0xc5da,0xc61a,
-0xc65a,0xc69a,0xc6da,0,0xc71a,0xc75a,0xc79a,0xc7da,0x8a,0xff89,0x8a,0xff89,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,1,0,0,0,0,0,0,0,4,0,
-0,0,0x64,0,0,0,0,4,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x64,4,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,0x64,
+4,4,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+1,1,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,5,1,1,1,1,1,1,1,1,0x92,0xff91,0x92,
+0xff91,0x50fa,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,0x92,0xff91,4,4,4,0x92,
+0xff91,0x511a,1,0,0x92,0xff91,0x92,0xff91,1,1,0x92,0xff91,0x92,0xff91,0x92,0xff91,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0x513a,0x515a,0x517a,0x519a,0x513a,1,0x51ba,0x51da,0x51fa,0x521a,
+0x92,0xff91,0x92,0xff91,0x92,0xff91,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,1,0,0,0,0,0,0,0,4,0,0,0,0x64,0,
+0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x64,4,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
+0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,
+0,0,0,4,0,0,0,0,0,0,4,4,4,4,4,0x64,
 0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,
 4,4,0,0x60,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -580,300 +591,292 @@ static const uint16_t ucase_props_trieIndex[11720]={
 0,0,0,0,0,0,0,0,4,4,0,0,0,0,0,4,
 4,0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0xc819,1,1,1,1,1,1,1,4,
+1,1,1,1,1,1,1,0x5239,1,1,1,1,1,1,1,4,
 5,5,5,5,1,1,1,1,1,1,0,0,0,0,0,0,
-0,0,0,0,0xc859,0xc8b9,0xc919,0xc979,0xc9d9,0xca39,0xca99,0xcaf9,0xcb59,0xcbb9,0xcc19,0xcc79,
-0xccd9,0xcd39,0xcd99,0xcdf9,0xda59,0xdab9,0xdb19,0xdb79,0xdbd9,0xdc39,0xdc99,0xdcf9,0xdd59,0xddb9,0xde19,0xde79,
-0xded9,0xdf39,0xdf99,0xdff9,0xe059,0xe0b9,0xe119,0xe179,0xe1d9,0xe239,0xe299,0xe2f9,0xe359,0xe3b9,0xe419,0xe479,
-0xe4d9,0xe539,0xe599,0xe5f9,0xce59,0xceb9,0xcf19,0xcf79,0xcfd9,0xd039,0xd099,0xd0f9,0xd159,0xd1b9,0xd219,0xd279,
-0xd2d9,0xd339,0xd399,0xd3f9,0xd459,0xd4b9,0xd519,0xd579,0xd5d9,0xd639,0xd699,0xd6f9,0xd759,0xd7b9,0xd819,0xd879,
-0xd8d9,0xd939,0xd999,0xd9f9,0,0,0,0,0,4,0,0,4,0,0,0,
+0,0,0,0,0x5259,0x5289,0x52b9,0x52e9,0x5319,0x5349,0x5379,0x53a9,0x53d9,0x5409,0x5439,0x5469,
+0x5499,0x54c9,0x54f9,0x5529,0x5b59,0x5b89,0x5bb9,0x5be9,0x5c19,0x5c49,0x5c79,0x5ca9,0x5cd9,0x5d09,0x5d39,0x5d69,
+0x5d99,0x5dc9,0x5df9,0x5e29,0x5e59,0x5e89,0x5eb9,0x5ee9,0x5f19,0x5f49,0x5f79,0x5fa9,0x5fd9,0x6009,0x6039,0x6069,
+0x6099,0x60c9,0x60f9,0x6129,0x5559,0x5589,0x55b9,0x55e9,0x5619,0x5649,0x5679,0x56a9,0x56d9,0x5709,0x5739,0x5769,
+0x5799,0x57c9,0x57f9,0x5829,0x5859,0x5889,0x58b9,0x58e9,0x5919,0x5949,0x5979,0x59a9,0x59d9,0x5a09,0x5a39,0x5a69,
+0x5a99,0x5ac9,0x5af9,0x5b29,0,0,0,0,0,4,0,0,4,0,0,0,
 0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0xe659,0xe759,0xe859,0xe959,0xeab9,0xec19,0xed59,0,0,0,0,0,
-0,0,0,0,0,0,0,0xee99,0xef99,0xf099,0xf199,0xf299,0,0,0,0,
+0,0,0,0,0x6159,0x61d9,0x6259,0x62d9,0x6389,0x6439,0x64d9,0,0,0,0,0,
+0,0,0,0,0,0,0,0x6579,0x65f9,0x6679,0x66f9,0x6779,0,0,0,0,
 0,0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,
 4,4,4,4,4,4,4,4,0,0,0,4,0,0,0,0,
 0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x64,
 0x64,0x64,0x64,0x64,0x64,0x64,0x44,0x44,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,4,0,0,4,0,0,
-0,0,0,0,0,0,0,0,0,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0,0,0,4,0,4,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,
+0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,
+0x1012,0x1012,0x1012,0,0,0,4,0,4,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,
+0xf011,0xf011,0xf011,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,
-0,0,0,0,0x64,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,
-0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,
-0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,
-0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,
-0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,
-0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0,0,0,0,
-0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,
-0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0xec09,0,0,0,0,
-0,4,4,4,0,4,4,0,0,0,0,0,4,0x64,4,0x44,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x44,0x64,0x64,0,0,0,0,0x64,
-0,0,0,0,0,0x44,0x64,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,
-0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,0x200a,
-0x200a,0x200a,0x200a,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,
-0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,0xe009,
-0xe009,0xe009,0xe009,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,
-4,4,4,4,4,4,0x64,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,4,4,4,0,0,0x64,0x64,0,0,4,0,0,
-0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,4,4,4,4,0,4,4,4,4,4,4,0x64,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,0,0,
 0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x64,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,
-4,4,4,4,4,4,4,0,0x60,0,0,0,0,0,0,0,
-0,0,0x64,4,4,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,4,4,4,0,0,
-4,0x60,0x64,4,0,0,0,0,0,0,4,0,0,0,0,4,
-4,4,4,4,4,0x64,0x64,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
-0,0,0,0,0,0,0,0,0,0x60,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0,0,0,0x44,0x44,0x44,0x44,0x44,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x64,4,4,0,0x64,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,
-4,0,4,0,0,0,0,4,4,0,0x64,0x64,0,0,0,0,
+0,0,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0x1412,0x1412,0x1412,0x1412,
+0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,
+0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0xec11,0xec11,0xec11,0xec11,
+0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,
+0xec11,0xec11,0xec11,0xec11,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,
+0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0x1412,0,0,0,0,0xec11,0xec11,0xec11,0xec11,
+0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,
+0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0xec11,0,0,0,0,0,4,4,4,
+0,4,4,0,0,0,0,0,4,0x64,4,0x44,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x44,0x64,0x64,0,0,0,0,0x64,0,0,0,0,
+0,0x44,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x2012,0x2012,0x2012,0x2012,
+0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,
+0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0x2012,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0xe011,0xe011,0xe011,0xe011,
+0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,
+0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0xe011,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,4,4,4,4,0,0,
-0,0,0,0,4,4,0,0x64,0x64,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x64,0x64,0x44,0x44,0x44,0x64,
+0x44,0x64,0x64,0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,4,4,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,
-4,4,4,0,0,4,0,0x64,0,0,0,0,0,0,0,0,
-0,0,0,4,0,4,0,0,4,4,4,4,4,4,0x60,0x64,
+4,4,4,4,4,4,4,4,4,4,0x64,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,
-0,0,4,4,4,4,0,4,4,4,4,0x64,0,0,0,0,
+0,0,0,0,0,0,0,4,4,4,4,0,0,0x64,0x64,0,
+0,4,0,0,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,0x100a,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,
-0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,0xf009,
-0,4,4,4,4,4,4,0,0,4,4,0,0,0,0,0,
+0,0,0,0,0,0,0,4,4,4,4,4,0,4,4,4,
+4,4,4,0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0x64,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,4,0x64,4,4,4,4,0,0,4,4,4,4,0,
-0,0,0,0,0,0,0,0x64,0,0,0,0,0,0,0,0,
-0,4,4,4,4,4,4,0,0,4,4,4,0,0,0,0,
-0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,
-4,4,4,0,4,0x64,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,0,
-4,4,4,4,4,4,0,0x64,4,4,4,4,4,4,4,4,
-0,0,4,4,4,4,4,4,4,0,4,4,0,4,4,0,
+0,0,4,4,4,4,4,4,4,4,4,0,0x60,0,0,0,
+0,0,0,0,0,4,0x64,4,4,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
+4,4,0,0,4,0x60,0x64,4,0,0,0,0,0,0,4,0,
+0,0,0,4,4,4,4,4,4,0x64,0x64,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,4,4,4,4,4,4,0,0,0,4,0,4,4,0,4,
-4,4,0x64,4,0x64,0x64,0,4,0,0,0,0,0,0,0,0,
+4,0,0,0,0,0,0,0,0,0,0,0,0,0x60,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x64,0x64,0x64,0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,
+0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0x44,0x44,0x44,0x44,
+0x44,0,0,0,0,0,0,0,0,0,0,0,0,0,0x64,4,
+4,0,0x64,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x44,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
-4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+4,4,4,4,4,0,4,0,0,0,0,4,4,0,0x64,0x64,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0x64,0,
-0,0,0,0,0,0x60,0x60,0x64,0x64,0x64,0,0,0,0x60,0x60,0x60,
-0x60,0x60,0x60,4,4,4,4,4,4,4,4,0x64,0x64,0x64,0x64,0x64,
-0x64,0x64,0x64,0,0,0x44,0x44,0x44,0x44,0x44,0x64,0x64,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,
+4,4,0,0,0,0,0,0,4,4,0,0x64,0x64,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
+4,4,4,4,4,4,4,0,0,4,0,0x64,0,0,0,0,
+0,0,0,0,0,0,0,4,0,4,0,0,4,4,4,4,
+4,4,0x60,0x64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,4,4,4,0,0,4,4,4,4,0,4,4,4,4,0x64,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,
+0,0x64,0x64,0,0,0,0,0,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,
+0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,
+0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0x1012,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,
+0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0xf011,0,4,4,4,4,4,4,4,
+4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,4,0x64,4,4,4,
+4,0,0,4,4,4,4,0,0,0,0,0,0,0,0,0x64,
+0,0,0,0,0,0,0,0,0,4,4,4,4,4,4,0,
+0,4,4,4,0,0,0,0,0,0,0,0,0,0,4,4,
+4,4,4,4,4,4,4,4,4,4,4,0,4,0x64,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,4,4,4,4,4,4,0,4,4,4,4,4,4,0,0x64,
+4,4,4,4,4,4,4,4,0,0,4,4,4,4,4,4,
+4,0,4,4,0,4,4,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,4,4,4,4,4,4,0,
+0,0,4,0,4,4,0,4,4,4,0x64,4,0x64,0x64,0,4,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,4,4,0,0,0,4,0,0x64,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,4,4,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x64,0x64,0x64,0x64,0x64,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0x44,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0,0,0,
+0,0,0,0,0,4,0x64,0,0,0,0,0,0,0x60,0x60,0x64,
+0x64,0x64,0,0,0,0x60,0x60,0x60,0x60,0x60,0x60,4,4,4,4,4,
+4,4,4,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0,0x44,0x44,0x44,
+0x44,0x44,0x64,0x64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,1,1,1,1,1,1,1,1,0x21,0x21,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,
-1,0,0x21,0x21,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,1,1,1,1,1,1,1,1,0x21,0x21,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-2,0,2,2,0,0,2,0,0,2,2,0,0,2,2,2,
-2,0,2,2,2,2,2,2,2,2,1,1,1,1,0,1,
-0,1,0x21,0x21,1,1,1,1,0,1,1,1,1,1,1,1,
+1,1,0x21,0x21,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,1,1,1,1,1,1,1,0,0x21,0x21,1,1,1,1,
 1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,1,1,1,1,2,2,0,2,2,2,2,0,
-0,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,
-2,0,1,1,1,1,1,1,1,1,0x21,0x21,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,0,2,
-2,2,2,0,2,2,2,2,2,0,2,0,0,0,2,2,
-2,2,2,2,2,0,1,1,1,1,1,1,1,1,0x21,0x21,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,
+1,1,1,1,1,1,0x21,0x21,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,2,0,2,2,0,0,2,0,
+0,2,2,0,0,2,2,2,2,0,2,2,2,2,2,2,
+2,2,1,1,1,1,0,1,0,1,0x21,0x21,1,1,1,1,
+0,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
+2,2,0,2,2,2,2,0,0,2,2,2,2,2,2,2,
+2,0,2,2,2,2,2,2,2,0,1,1,1,1,1,1,
+1,1,0x21,0x21,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,2,2,0,2,2,2,2,0,2,2,2,2,
+2,0,2,0,0,0,2,2,2,2,2,2,2,0,1,1,
+1,1,1,1,1,1,0x21,0x21,1,1,1,1,1,1,1,1,
+1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,0,0,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,0,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0,1,1,1,1,1,1,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-1,1,1,1,1,1,0,0,2,2,2,2,2,2,2,2,
+2,2,2,0,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,
-1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,0,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,0,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,1,1,1,0,1,1,1,1,
-1,1,2,1,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,0,
-0,0,0,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
-0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,
-0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0,0x44,0x44,0x44,0x44,0x44,
-0x44,0x44,0,0x44,0x44,0,0x44,0x44,0x44,0x44,0x44,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,0,0,0,0,0,0,0,0,
-0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,
-0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,
-0x110a,0x110a,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,
-0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,0xef09,
-0x44,0x44,0x44,0x44,0x44,0x44,0x64,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,
-2,2,2,2,2,2,0,0,0,0,0,0,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0
+1,1,1,0,1,1,1,1,1,1,2,1,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,0,0,0,0,4,4,4,4,4,
+4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,
+0,4,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,4,4,4,4,4,0,4,4,4,4,4,4,4,
+4,4,4,4,4,4,4,4,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,
+0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0x44,
+0x44,0,0,0x44,0x44,0x44,0x44,0x44,0x44,0x44,0,0x44,0x44,0,0x44,0x44,
+0x44,0x44,0x44,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x64,0x64,0x64,0x64,0x64,0x64,0x64,0,
+0,0,0,0,0,0,0,0,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,
+0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,
+0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0x1112,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,
+0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,
+0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0xef11,0x44,0x44,0x44,0x44,0x44,0x44,0x64,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,2,2,2,2,2,2,2,2,2,2,0,0,
+0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 };
 
-static const uint16_t ucase_props_exceptions[1948]={
-0xc041,0x69,2,0x130,0x131,0x4001,0x6a,0x41,0x6b,1,0x212a,0x41,0x73,1,0x17f,0x5044,
-0x49,2,0x130,0x131,0x44,0x4b,1,0x212a,0x44,0x53,1,0x17f,6,0x3bc,0x39c,0x41,
-0xe5,1,0x212b,0x4001,0xec,0x4001,0xed,0xc0,1,0x2220,0x73,0x73,0x53,0x53,0x53,0x73,
-0x1e9e,0x44,0xc5,1,0x212b,0x4001,0x129,0x4001,0x12f,0xc043,0x69,0x130,2,0x49,0x131,0x44,
-0x49,2,0x69,0x130,0x80,0x2220,0x2bc,0x6e,0x2bc,0x4e,0x2bc,0x4e,6,0x73,0x53,9,
-0x1c6,0x1c5,0xd,0x1c6,0x1c4,0x1c5,0xc,0x1c4,0x1c5,9,0x1c9,0x1c8,0xd,0x1c9,0x1c7,0x1c8,
-0xc,0x1c7,0x1c8,9,0x1cc,0x1cb,0xd,0x1cc,0x1ca,0x1cb,0xc,0x1ca,0x1cb,0x80,0x2220,0x6a,
-0x30c,0x4a,0x30c,0x4a,0x30c,9,0x1f3,0x1f2,0xd,0x1f3,0x1f1,0x1f2,0xc,0x1f1,0x1f2,1,
-0x2c65,1,0x2c66,4,0x2c7e,4,0x2c7f,4,0x2c6f,4,0x2c6d,4,0x2c70,4,0xa7ab,4,
-0xa7ac,4,0xa78d,4,0xa7aa,4,0xa7ae,4,0x2c62,4,0xa7ad,4,0x2c6e,4,0x2c64,4,
-0xa7b1,0x1004,0xa7b2,4,0xa7b0,0x6000,0x3046,0x3b9,0x399,1,0x1fbe,0xc0,1,0x3330,0x3b9,0x308,
-0x301,0x399,0x308,0x301,0x399,0x308,0x301,0x1fd3,0x41,0x3b2,1,0x3d0,0x41,0x3b5,1,0x3f5,
-0x41,0x3b8,2,0x3d1,0x3f4,0x41,0x3b9,2,0x345,0x1fbe,0x41,0x3ba,1,0x3f0,0x41,0x3bc,
-1,0xb5,0x41,0x3c0,1,0x3d6,0x41,0x3c1,1,0x3f1,0x4041,0x3c3,1,0x3c2,0x41,0x3c6,
-1,0x3d5,0x41,0x3c9,1,0x2126,0xc0,1,0x3330,0x3c5,0x308,0x301,0x3a5,0x308,0x301,0x3a5,
-0x308,0x301,0x1fe3,0x44,0x392,1,0x3d0,0x44,0x395,1,0x3f5,0x44,0x398,2,0x3d1,0x3f4,
-0x44,0x399,2,0x345,0x1fbe,0x44,0x39a,1,0x3f0,0x44,0x39c,1,0xb5,0x44,0x3a0,1,
-0x3d6,0x44,0x3a1,1,0x3f1,6,0x3c3,0x3a3,0x44,0x3a3,1,0x3c2,0x44,0x3a6,1,0x3d5,
-0x44,0x3a9,1,0x2126,6,0x3b2,0x392,0x46,0x3b8,0x398,1,0x3f4,6,0x3c6,0x3a6,6,
-0x3c0,0x3a0,6,0x3ba,0x39a,6,0x3c1,0x3a1,0x41,0x3b8,2,0x398,0x3d1,6,0x3b5,0x395,
-0x41,0x432,1,0x1c80,0x41,0x434,1,0x1c81,0x41,0x43e,1,0x1c82,0x41,0x441,1,0x1c83,
-0x41,0x442,2,0x1c84,0x1c85,0x41,0x44a,1,0x1c86,0x44,0x412,1,0x1c80,0x44,0x414,1,
-0x1c81,0x44,0x41e,1,0x1c82,0x44,0x421,1,0x1c83,0x44,0x422,2,0x1c84,0x1c85,0x44,0x42a,
-1,0x1c86,0x41,0x463,1,0x1c87,0x44,0x462,1,0x1c87,0x80,0x2220,0x565,0x582,0x535,0x552,
-0x535,0x582,1,0x2d00,1,0x2d01,1,0x2d02,1,0x2d03,1,0x2d04,1,0x2d05,1,0x2d06,
-1,0x2d07,1,0x2d08,1,0x2d09,1,0x2d0a,1,0x2d0b,1,0x2d0c,1,0x2d0d,1,0x2d0e,
-1,0x2d0f,1,0x2d10,1,0x2d11,1,0x2d12,1,0x2d13,1,0x2d14,1,0x2d15,1,0x2d16,
-1,0x2d17,1,0x2d18,1,0x2d19,1,0x2d1a,1,0x2d1b,1,0x2d1c,1,0x2d1d,1,0x2d1e,
-1,0x2d1f,1,0x2d20,1,0x2d21,1,0x2d22,1,0x2d23,1,0x2d24,1,0x2d25,1,0x2d27,
-1,0x2d2d,3,0xab70,0x13a0,3,0xab71,0x13a1,3,0xab72,0x13a2,3,0xab73,0x13a3,3,0xab74,
-0x13a4,3,0xab75,0x13a5,3,0xab76,0x13a6,3,0xab77,0x13a7,3,0xab78,0x13a8,3,0xab79,0x13a9,
-3,0xab7a,0x13aa,3,0xab7b,0x13ab,3,0xab7c,0x13ac,3,0xab7d,0x13ad,3,0xab7e,0x13ae,3,
-0xab7f,0x13af,3,0xab80,0x13b0,3,0xab81,0x13b1,3,0xab82,0x13b2,3,0xab83,0x13b3,3,0xab84,
-0x13b4,3,0xab85,0x13b5,3,0xab86,0x13b6,3,0xab87,0x13b7,3,0xab88,0x13b8,3,0xab89,0x13b9,
-3,0xab8a,0x13ba,3,0xab8b,0x13bb,3,0xab8c,0x13bc,3,0xab8d,0x13bd,3,0xab8e,0x13be,3,
-0xab8f,0x13bf,3,0xab90,0x13c0,3,0xab91,0x13c1,3,0xab92,0x13c2,3,0xab93,0x13c3,3,0xab94,
-0x13c4,3,0xab95,0x13c5,3,0xab96,0x13c6,3,0xab97,0x13c7,3,0xab98,0x13c8,3,0xab99,0x13c9,
-3,0xab9a,0x13ca,3,0xab9b,0x13cb,3,0xab9c,0x13cc,3,0xab9d,0x13cd,3,0xab9e,0x13ce,3,
-0xab9f,0x13cf,3,0xaba0,0x13d0,3,0xaba1,0x13d1,3,0xaba2,0x13d2,3,0xaba3,0x13d3,3,0xaba4,
-0x13d4,3,0xaba5,0x13d5,3,0xaba6,0x13d6,3,0xaba7,0x13d7,3,0xaba8,0x13d8,3,0xaba9,0x13d9,
-3,0xabaa,0x13da,3,0xabab,0x13db,3,0xabac,0x13dc,3,0xabad,0x13dd,3,0xabae,0x13de,3,
-0xabaf,0x13df,3,0xabb0,0x13e0,3,0xabb1,0x13e1,3,0xabb2,0x13e2,3,0xabb3,0x13e3,3,0xabb4,
-0x13e4,3,0xabb5,0x13e5,3,0xabb6,0x13e6,3,0xabb7,0x13e7,3,0xabb8,0x13e8,3,0xabb9,0x13e9,
-3,0xabba,0x13ea,3,0xabbb,0x13eb,3,0xabbc,0x13ec,3,0xabbd,0x13ed,3,0xabbe,0x13ee,3,
-0xabbf,0x13ef,3,0x13f8,0x13f0,3,0x13f9,0x13f1,3,0x13fa,0x13f2,3,0x13fb,0x13f3,3,0x13fc,
-0x13f4,3,0x13fd,0x13f5,6,0x13f0,0x13f0,6,0x13f1,0x13f1,6,0x13f2,0x13f2,6,0x13f3,0x13f3,
-6,0x13f4,0x13f4,6,0x13f5,0x13f5,6,0x432,0x412,6,0x434,0x414,6,0x43e,0x41e,6,
-0x441,0x421,0x46,0x442,0x422,1,0x1c85,0x46,0x442,0x422,1,0x1c84,6,0x44a,0x42a,6,
-0x463,0x462,6,0xa64b,0xa64a,4,0xa77d,4,0x2c63,0x41,0x1e61,1,0x1e9b,0x44,0x1e60,1,
-0x1e9b,0x80,0x2220,0x68,0x331,0x48,0x331,0x48,0x331,0x80,0x2220,0x74,0x308,0x54,0x308,0x54,
-0x308,0x80,0x2220,0x77,0x30a,0x57,0x30a,0x57,0x30a,0x80,0x2220,0x79,0x30a,0x59,0x30a,0x59,
-0x30a,0x80,0x2220,0x61,0x2be,0x41,0x2be,0x41,0x2be,6,0x1e61,0x1e60,0x81,0xdf,0x20,0x73,
-0x73,0x80,0x2220,0x3c5,0x313,0x3a5,0x313,0x3a5,0x313,0x80,0x3330,0x3c5,0x313,0x300,0x3a5,0x313,
-0x300,0x3a5,0x313,0x300,0x80,0x3330,0x3c5,0x313,0x301,0x3a5,0x313,0x301,0x3a5,0x313,0x301,0x80,
-0x3330,0x3c5,0x313,0x342,0x3a5,0x313,0x342,0x3a5,0x313,0x342,0x84,0x1f88,0x220,0x1f00,0x3b9,0x1f08,
-0x399,0x84,0x1f89,0x220,0x1f01,0x3b9,0x1f09,0x399,0x84,0x1f8a,0x220,0x1f02,0x3b9,0x1f0a,0x399,0x84,
-0x1f8b,0x220,0x1f03,0x3b9,0x1f0b,0x399,0x84,0x1f8c,0x220,0x1f04,0x3b9,0x1f0c,0x399,0x84,0x1f8d,0x220,
-0x1f05,0x3b9,0x1f0d,0x399,0x84,0x1f8e,0x220,0x1f06,0x3b9,0x1f0e,0x399,0x84,0x1f8f,0x220,0x1f07,0x3b9,
-0x1f0f,0x399,0x81,0x1f80,0x220,0x1f00,0x3b9,0x1f08,0x399,0x81,0x1f81,0x220,0x1f01,0x3b9,0x1f09,0x399,
-0x81,0x1f82,0x220,0x1f02,0x3b9,0x1f0a,0x399,0x81,0x1f83,0x220,0x1f03,0x3b9,0x1f0b,0x399,0x81,0x1f84,
-0x220,0x1f04,0x3b9,0x1f0c,0x399,0x81,0x1f85,0x220,0x1f05,0x3b9,0x1f0d,0x399,0x81,0x1f86,0x220,0x1f06,
-0x3b9,0x1f0e,0x399,0x81,0x1f87,0x220,0x1f07,0x3b9,0x1f0f,0x399,0x84,0x1f98,0x220,0x1f20,0x3b9,0x1f28,
-0x399,0x84,0x1f99,0x220,0x1f21,0x3b9,0x1f29,0x399,0x84,0x1f9a,0x220,0x1f22,0x3b9,0x1f2a,0x399,0x84,
-0x1f9b,0x220,0x1f23,0x3b9,0x1f2b,0x399,0x84,0x1f9c,0x220,0x1f24,0x3b9,0x1f2c,0x399,0x84,0x1f9d,0x220,
-0x1f25,0x3b9,0x1f2d,0x399,0x84,0x1f9e,0x220,0x1f26,0x3b9,0x1f2e,0x399,0x84,0x1f9f,0x220,0x1f27,0x3b9,
-0x1f2f,0x399,0x81,0x1f90,0x220,0x1f20,0x3b9,0x1f28,0x399,0x81,0x1f91,0x220,0x1f21,0x3b9,0x1f29,0x399,
-0x81,0x1f92,0x220,0x1f22,0x3b9,0x1f2a,0x399,0x81,0x1f93,0x220,0x1f23,0x3b9,0x1f2b,0x399,0x81,0x1f94,
-0x220,0x1f24,0x3b9,0x1f2c,0x399,0x81,0x1f95,0x220,0x1f25,0x3b9,0x1f2d,0x399,0x81,0x1f96,0x220,0x1f26,
-0x3b9,0x1f2e,0x399,0x81,0x1f97,0x220,0x1f27,0x3b9,0x1f2f,0x399,0x84,0x1fa8,0x220,0x1f60,0x3b9,0x1f68,
-0x399,0x84,0x1fa9,0x220,0x1f61,0x3b9,0x1f69,0x399,0x84,0x1faa,0x220,0x1f62,0x3b9,0x1f6a,0x399,0x84,
-0x1fab,0x220,0x1f63,0x3b9,0x1f6b,0x399,0x84,0x1fac,0x220,0x1f64,0x3b9,0x1f6c,0x399,0x84,0x1fad,0x220,
-0x1f65,0x3b9,0x1f6d,0x399,0x84,0x1fae,0x220,0x1f66,0x3b9,0x1f6e,0x399,0x84,0x1faf,0x220,0x1f67,0x3b9,
-0x1f6f,0x399,0x81,0x1fa0,0x220,0x1f60,0x3b9,0x1f68,0x399,0x81,0x1fa1,0x220,0x1f61,0x3b9,0x1f69,0x399,
-0x81,0x1fa2,0x220,0x1f62,0x3b9,0x1f6a,0x399,0x81,0x1fa3,0x220,0x1f63,0x3b9,0x1f6b,0x399,0x81,0x1fa4,
-0x220,0x1f64,0x3b9,0x1f6c,0x399,0x81,0x1fa5,0x220,0x1f65,0x3b9,0x1f6d,0x399,0x81,0x1fa6,0x220,0x1f66,
-0x3b9,0x1f6e,0x399,0x81,0x1fa7,0x220,0x1f67,0x3b9,0x1f6f,0x399,0x80,0x2220,0x1f70,0x3b9,0x1fba,0x399,
-0x1fba,0x345,0x84,0x1fbc,0x220,0x3b1,0x3b9,0x391,0x399,0x80,0x2220,0x3ac,0x3b9,0x386,0x399,0x386,
-0x345,0x80,0x2220,0x3b1,0x342,0x391,0x342,0x391,0x342,0x80,0x3330,0x3b1,0x342,0x3b9,0x391,0x342,
-0x399,0x391,0x342,0x345,0x81,0x1fb3,0x220,0x3b1,0x3b9,0x391,0x399,0x46,0x3b9,0x399,1,0x345,
-0x80,0x2220,0x1f74,0x3b9,0x1fca,0x399,0x1fca,0x345,0x84,0x1fcc,0x220,0x3b7,0x3b9,0x397,0x399,0x80,
-0x2220,0x3ae,0x3b9,0x389,0x399,0x389,0x345,0x80,0x2220,0x3b7,0x342,0x397,0x342,0x397,0x342,0x80,
-0x3330,0x3b7,0x342,0x3b9,0x397,0x342,0x399,0x397,0x342,0x345,0x81,0x1fc3,0x220,0x3b7,0x3b9,0x397,
-0x399,0x80,0x3330,0x3b9,0x308,0x300,0x399,0x308,0x300,0x399,0x308,0x300,0xc0,1,0x3330,0x3b9,
-0x308,0x301,0x399,0x308,0x301,0x399,0x308,0x301,0x390,0x80,0x2220,0x3b9,0x342,0x399,0x342,0x399,
-0x342,0x80,0x3330,0x3b9,0x308,0x342,0x399,0x308,0x342,0x399,0x308,0x342,0x80,0x3330,0x3c5,0x308,
-0x300,0x3a5,0x308,0x300,0x3a5,0x308,0x300,0xc0,1,0x3330,0x3c5,0x308,0x301,0x3a5,0x308,0x301,
-0x3a5,0x308,0x301,0x3b0,0x80,0x2220,0x3c1,0x313,0x3a1,0x313,0x3a1,0x313,0x80,0x2220,0x3c5,0x342,
-0x3a5,0x342,0x3a5,0x342,0x80,0x3330,0x3c5,0x308,0x342,0x3a5,0x308,0x342,0x3a5,0x308,0x342,0x80,
-0x2220,0x1f7c,0x3b9,0x1ffa,0x399,0x1ffa,0x345,0x84,0x1ffc,0x220,0x3c9,0x3b9,0x3a9,0x399,0x80,0x2220,
-0x3ce,0x3b9,0x38f,0x399,0x38f,0x345,0x80,0x2220,0x3c9,0x342,0x3a9,0x342,0x3a9,0x342,0x80,0x3330,
-0x3c9,0x342,0x3b9,0x3a9,0x342,0x399,0x3a9,0x342,0x345,0x81,0x1ff3,0x220,0x3c9,0x3b9,0x3a9,0x399,
-0x41,0x3c9,1,0x3a9,0x41,0x6b,1,0x4b,0x41,0xe5,1,0xc5,1,0x26b,1,0x1d7d,
-1,0x27d,4,0x23a,4,0x23e,1,0x251,1,0x271,1,0x250,1,0x252,1,0x23f,
-1,0x240,4,0x10a0,4,0x10a1,4,0x10a2,4,0x10a3,4,0x10a4,4,0x10a5,4,0x10a6,
-4,0x10a7,4,0x10a8,4,0x10a9,4,0x10aa,4,0x10ab,4,0x10ac,4,0x10ad,4,0x10ae,
-4,0x10af,4,0x10b0,4,0x10b1,4,0x10b2,4,0x10b3,4,0x10b4,4,0x10b5,4,0x10b6,
-4,0x10b7,4,0x10b8,4,0x10b9,4,0x10ba,4,0x10bb,4,0x10bc,4,0x10bd,4,0x10be,
-4,0x10bf,4,0x10c0,4,0x10c1,4,0x10c2,4,0x10c3,4,0x10c4,4,0x10c5,4,0x10c7,
-4,0x10cd,0x41,0xa64b,1,0x1c88,0x44,0xa64a,1,0x1c88,1,0x1d79,1,0x265,1,0x266,
-1,0x25c,1,0x261,1,0x26c,1,0x26a,1,0x29e,1,0x287,1,0x29d,1,0xab53,
-4,0xa7b3,6,0x13a0,0x13a0,6,0x13a1,0x13a1,6,0x13a2,0x13a2,6,0x13a3,0x13a3,6,0x13a4,
-0x13a4,6,0x13a5,0x13a5,6,0x13a6,0x13a6,6,0x13a7,0x13a7,6,0x13a8,0x13a8,6,0x13a9,0x13a9,
-6,0x13aa,0x13aa,6,0x13ab,0x13ab,6,0x13ac,0x13ac,6,0x13ad,0x13ad,6,0x13ae,0x13ae,6,
-0x13af,0x13af,6,0x13b0,0x13b0,6,0x13b1,0x13b1,6,0x13b2,0x13b2,6,0x13b3,0x13b3,6,0x13b4,
-0x13b4,6,0x13b5,0x13b5,6,0x13b6,0x13b6,6,0x13b7,0x13b7,6,0x13b8,0x13b8,6,0x13b9,0x13b9,
-6,0x13ba,0x13ba,6,0x13bb,0x13bb,6,0x13bc,0x13bc,6,0x13bd,0x13bd,6,0x13be,0x13be,6,
-0x13bf,0x13bf,6,0x13c0,0x13c0,6,0x13c1,0x13c1,6,0x13c2,0x13c2,6,0x13c3,0x13c3,6,0x13c4,
-0x13c4,6,0x13c5,0x13c5,6,0x13c6,0x13c6,6,0x13c7,0x13c7,6,0x13c8,0x13c8,6,0x13c9,0x13c9,
-6,0x13ca,0x13ca,6,0x13cb,0x13cb,6,0x13cc,0x13cc,6,0x13cd,0x13cd,6,0x13ce,0x13ce,6,
-0x13cf,0x13cf,6,0x13d0,0x13d0,6,0x13d1,0x13d1,6,0x13d2,0x13d2,6,0x13d3,0x13d3,6,0x13d4,
-0x13d4,6,0x13d5,0x13d5,6,0x13d6,0x13d6,6,0x13d7,0x13d7,6,0x13d8,0x13d8,6,0x13d9,0x13d9,
-6,0x13da,0x13da,6,0x13db,0x13db,6,0x13dc,0x13dc,6,0x13dd,0x13dd,6,0x13de,0x13de,6,
-0x13df,0x13df,6,0x13e0,0x13e0,6,0x13e1,0x13e1,6,0x13e2,0x13e2,6,0x13e3,0x13e3,6,0x13e4,
-0x13e4,6,0x13e5,0x13e5,6,0x13e6,0x13e6,6,0x13e7,0x13e7,6,0x13e8,0x13e8,6,0x13e9,0x13e9,
-6,0x13ea,0x13ea,6,0x13eb,0x13eb,6,0x13ec,0x13ec,6,0x13ed,0x13ed,6,0x13ee,0x13ee,6,
-0x13ef,0x13ef,0x80,0x2220,0x66,0x66,0x46,0x46,0x46,0x66,0x80,0x2220,0x66,0x69,0x46,0x49,
-0x46,0x69,0x80,0x2220,0x66,0x6c,0x46,0x4c,0x46,0x6c,0x80,0x3330,0x66,0x66,0x69,0x46,
-0x46,0x49,0x46,0x66,0x69,0x80,0x3330,0x66,0x66,0x6c,0x46,0x46,0x4c,0x46,0x66,0x6c,
-0xc0,1,0x2220,0x73,0x74,0x53,0x54,0x53,0x74,0xfb06,0xc0,1,0x2220,0x73,0x74,0x53,
-0x54,0x53,0x74,0xfb05,0x80,0x2220,0x574,0x576,0x544,0x546,0x544,0x576,0x80,0x2220,0x574,0x565,
-0x544,0x535,0x544,0x565,0x80,0x2220,0x574,0x56b,0x544,0x53b,0x544,0x56b,0x80,0x2220,0x57e,0x576,
-0x54e,0x546,0x54e,0x576,0x80,0x2220,0x574,0x56d,0x544,0x53d,0x544,0x56d
+static const uint16_t ucase_props_exceptions[1663]={
+0xc850,0x20,2,0x130,0x131,0x4810,0x20,0x841,0x6b,1,0x212a,0x841,0x73,1,0x17f,0x5c50,
+0x20,2,0x130,0x131,0x844,0x4b,1,0x212a,0x844,0x53,1,0x17f,0x806,0x3bc,0x39c,0x841,
+0xe5,1,0x212b,0x8c0,1,0x2220,0x73,0x73,0x53,0x53,0x53,0x73,0x1e9e,0x844,0xc5,1,
+0x212b,0x4810,1,0xce50,0xc7,2,0x49,0x131,0x844,0x49,2,0x69,0x130,0x880,0x2220,0x2bc,
+0x6e,0x2bc,0x4e,0x2bc,0x4e,0x806,0x73,0x53,0x809,0x1c6,0x1c5,0x80d,0x1c6,0x1c4,0x1c5,0x80c,
+0x1c4,0x1c5,0x809,0x1c9,0x1c8,0x80d,0x1c9,0x1c7,0x1c8,0x80c,0x1c7,0x1c8,0x809,0x1cc,0x1cb,0x80d,
+0x1cc,0x1ca,0x1cb,0x80c,0x1ca,0x1cb,0x880,0x2220,0x6a,0x30c,0x4a,0x30c,0x4a,0x30c,0x809,0x1f3,
+0x1f2,0x80d,0x1f3,0x1f1,0x1f2,0x80c,0x1f1,0x1f2,0x810,0x2a2b,0x810,0x2a28,0x810,0x2a3f,0x810,0x2a1f,
+0x810,0x2a1c,0x810,0x2a1e,0x810,0xa54f,0x810,0xa54b,0x810,0xa528,0x810,0xa544,0x810,0x29f7,0x810,0xa541,
+0x810,0x29fd,0x810,0x29e7,0x810,0xa52a,0x1810,0xa515,0x810,0xa512,0x6800,0x3846,0x3b9,0x399,1,0x1fbe,
+0x8c0,1,0x3330,0x3b9,0x308,0x301,0x399,0x308,0x301,0x399,0x308,0x301,0x1fd3,0x841,0x3b2,1,
+0x3d0,0x841,0x3b5,1,0x3f5,0x841,0x3b8,2,0x3d1,0x3f4,0x841,0x3b9,2,0x345,0x1fbe,0x841,
+0x3ba,1,0x3f0,0x841,0x3bc,1,0xb5,0x841,0x3c0,1,0x3d6,0x841,0x3c1,1,0x3f1,0x4850,
+0x20,1,0x3c2,0x841,0x3c6,1,0x3d5,0x841,0x3c9,1,0x2126,0x8c0,1,0x3330,0x3c5,0x308,
+0x301,0x3a5,0x308,0x301,0x3a5,0x308,0x301,0x1fe3,0x844,0x392,1,0x3d0,0x844,0x395,1,0x3f5,
+0x844,0x398,2,0x3d1,0x3f4,0x844,0x399,2,0x345,0x1fbe,0x844,0x39a,1,0x3f0,0x844,0x39c,
+1,0xb5,0x844,0x3a0,1,0x3d6,0x844,0x3a1,1,0x3f1,0x806,0x3c3,0x3a3,0x844,0x3a3,1,
+0x3c2,0x844,0x3a6,1,0x3d5,0x844,0x3a9,1,0x2126,0x806,0x3b2,0x392,0x846,0x3b8,0x398,1,
+0x3f4,0x806,0x3c6,0x3a6,0x806,0x3c0,0x3a0,0x806,0x3ba,0x39a,0x806,0x3c1,0x3a1,0x841,0x3b8,2,
+0x398,0x3d1,0x806,0x3b5,0x395,0x841,0x432,1,0x1c80,0x841,0x434,1,0x1c81,0x841,0x43e,1,
+0x1c82,0x841,0x441,1,0x1c83,0x841,0x442,2,0x1c84,0x1c85,0x841,0x44a,1,0x1c86,0x844,0x412,
+1,0x1c80,0x844,0x414,1,0x1c81,0x844,0x41e,1,0x1c82,0x844,0x421,1,0x1c83,0x844,0x422,
+2,0x1c84,0x1c85,0x844,0x42a,1,0x1c86,0x841,0x463,1,0x1c87,0x844,0x462,1,0x1c87,0x880,
+0x2220,0x565,0x582,0x535,0x552,0x535,0x582,0x810,0x1c60,0x80c,0x1c90,0x10d0,0x80c,0x1c91,0x10d1,0x80c,
+0x1c92,0x10d2,0x80c,0x1c93,0x10d3,0x80c,0x1c94,0x10d4,0x80c,0x1c95,0x10d5,0x80c,0x1c96,0x10d6,0x80c,0x1c97,
+0x10d7,0x80c,0x1c98,0x10d8,0x80c,0x1c99,0x10d9,0x80c,0x1c9a,0x10da,0x80c,0x1c9b,0x10db,0x80c,0x1c9c,0x10dc,
+0x80c,0x1c9d,0x10dd,0x80c,0x1c9e,0x10de,0x80c,0x1c9f,0x10df,0x80c,0x1ca0,0x10e0,0x80c,0x1ca1,0x10e1,0x80c,
+0x1ca2,0x10e2,0x80c,0x1ca3,0x10e3,0x80c,0x1ca4,0x10e4,0x80c,0x1ca5,0x10e5,0x80c,0x1ca6,0x10e6,0x80c,0x1ca7,
+0x10e7,0x80c,0x1ca8,0x10e8,0x80c,0x1ca9,0x10e9,0x80c,0x1caa,0x10ea,0x80c,0x1cab,0x10eb,0x80c,0x1cac,0x10ec,
+0x80c,0x1cad,0x10ed,0x80c,0x1cae,0x10ee,0x80c,0x1caf,0x10ef,0x80c,0x1cb0,0x10f0,0x80c,0x1cb1,0x10f1,0x80c,
+0x1cb2,0x10f2,0x80c,0x1cb3,0x10f3,0x80c,0x1cb4,0x10f4,0x80c,0x1cb5,0x10f5,0x80c,0x1cb6,0x10f6,0x80c,0x1cb7,
+0x10f7,0x80c,0x1cb8,0x10f8,0x80c,0x1cb9,0x10f9,0x80c,0x1cba,0x10fa,0x80c,0x1cbd,0x10fd,0x80c,0x1cbe,0x10fe,
+0x80c,0x1cbf,0x10ff,0xa10,0x97d0,0xa10,8,0x806,0x13f0,0x13f0,0x806,0x13f1,0x13f1,0x806,0x13f2,0x13f2,
+0x806,0x13f3,0x13f3,0x806,0x13f4,0x13f4,0x806,0x13f5,0x13f5,0x806,0x432,0x412,0x806,0x434,0x414,0x806,
+0x43e,0x41e,0x806,0x441,0x421,0x846,0x442,0x422,1,0x1c85,0x846,0x442,0x422,1,0x1c84,0x806,
+0x44a,0x42a,0x806,0x463,0x462,0x806,0xa64b,0xa64a,0xc10,0xbc0,0x810,0x8a04,0x810,0xee6,0x841,0x1e61,
+1,0x1e9b,0x844,0x1e60,1,0x1e9b,0x880,0x2220,0x68,0x331,0x48,0x331,0x48,0x331,0x880,0x2220,
+0x74,0x308,0x54,0x308,0x54,0x308,0x880,0x2220,0x77,0x30a,0x57,0x30a,0x57,0x30a,0x880,0x2220,
+0x79,0x30a,0x59,0x30a,0x59,0x30a,0x880,0x2220,0x61,0x2be,0x41,0x2be,0x41,0x2be,0x806,0x1e61,
+0x1e60,0xc90,0x1dbf,0x20,0x73,0x73,0x880,0x2220,0x3c5,0x313,0x3a5,0x313,0x3a5,0x313,0x880,0x3330,
+0x3c5,0x313,0x300,0x3a5,0x313,0x300,0x3a5,0x313,0x300,0x880,0x3330,0x3c5,0x313,0x301,0x3a5,0x313,
+0x301,0x3a5,0x313,0x301,0x880,0x3330,0x3c5,0x313,0x342,0x3a5,0x313,0x342,0x3a5,0x313,0x342,0x890,
+8,0x220,0x1f00,0x3b9,0x1f08,0x399,0x890,8,0x220,0x1f01,0x3b9,0x1f09,0x399,0x890,8,0x220,
+0x1f02,0x3b9,0x1f0a,0x399,0x890,8,0x220,0x1f03,0x3b9,0x1f0b,0x399,0x890,8,0x220,0x1f04,0x3b9,
+0x1f0c,0x399,0x890,8,0x220,0x1f05,0x3b9,0x1f0d,0x399,0x890,8,0x220,0x1f06,0x3b9,0x1f0e,0x399,
+0x890,8,0x220,0x1f07,0x3b9,0x1f0f,0x399,0xc90,8,0x220,0x1f00,0x3b9,0x1f08,0x399,0xc90,8,
+0x220,0x1f01,0x3b9,0x1f09,0x399,0xc90,8,0x220,0x1f02,0x3b9,0x1f0a,0x399,0xc90,8,0x220,0x1f03,
+0x3b9,0x1f0b,0x399,0xc90,8,0x220,0x1f04,0x3b9,0x1f0c,0x399,0xc90,8,0x220,0x1f05,0x3b9,0x1f0d,
+0x399,0xc90,8,0x220,0x1f06,0x3b9,0x1f0e,0x399,0xc90,8,0x220,0x1f07,0x3b9,0x1f0f,0x399,0x890,
+8,0x220,0x1f20,0x3b9,0x1f28,0x399,0x890,8,0x220,0x1f21,0x3b9,0x1f29,0x399,0x890,8,0x220,
+0x1f22,0x3b9,0x1f2a,0x399,0x890,8,0x220,0x1f23,0x3b9,0x1f2b,0x399,0x890,8,0x220,0x1f24,0x3b9,
+0x1f2c,0x399,0x890,8,0x220,0x1f25,0x3b9,0x1f2d,0x399,0x890,8,0x220,0x1f26,0x3b9,0x1f2e,0x399,
+0x890,8,0x220,0x1f27,0x3b9,0x1f2f,0x399,0xc90,8,0x220,0x1f20,0x3b9,0x1f28,0x399,0xc90,8,
+0x220,0x1f21,0x3b9,0x1f29,0x399,0xc90,8,0x220,0x1f22,0x3b9,0x1f2a,0x399,0xc90,8,0x220,0x1f23,
+0x3b9,0x1f2b,0x399,0xc90,8,0x220,0x1f24,0x3b9,0x1f2c,0x399,0xc90,8,0x220,0x1f25,0x3b9,0x1f2d,
+0x399,0xc90,8,0x220,0x1f26,0x3b9,0x1f2e,0x399,0xc90,8,0x220,0x1f27,0x3b9,0x1f2f,0x399,0x890,
+8,0x220,0x1f60,0x3b9,0x1f68,0x399,0x890,8,0x220,0x1f61,0x3b9,0x1f69,0x399,0x890,8,0x220,
+0x1f62,0x3b9,0x1f6a,0x399,0x890,8,0x220,0x1f63,0x3b9,0x1f6b,0x399,0x890,8,0x220,0x1f64,0x3b9,
+0x1f6c,0x399,0x890,8,0x220,0x1f65,0x3b9,0x1f6d,0x399,0x890,8,0x220,0x1f66,0x3b9,0x1f6e,0x399,
+0x890,8,0x220,0x1f67,0x3b9,0x1f6f,0x399,0xc90,8,0x220,0x1f60,0x3b9,0x1f68,0x399,0xc90,8,
+0x220,0x1f61,0x3b9,0x1f69,0x399,0xc90,8,0x220,0x1f62,0x3b9,0x1f6a,0x399,0xc90,8,0x220,0x1f63,
+0x3b9,0x1f6b,0x399,0xc90,8,0x220,0x1f64,0x3b9,0x1f6c,0x399,0xc90,8,0x220,0x1f65,0x3b9,0x1f6d,
+0x399,0xc90,8,0x220,0x1f66,0x3b9,0x1f6e,0x399,0xc90,8,0x220,0x1f67,0x3b9,0x1f6f,0x399,0x880,
+0x2220,0x1f70,0x3b9,0x1fba,0x399,0x1fba,0x345,0x890,9,0x220,0x3b1,0x3b9,0x391,0x399,0x880,0x2220,
+0x3ac,0x3b9,0x386,0x399,0x386,0x345,0x880,0x2220,0x3b1,0x342,0x391,0x342,0x391,0x342,0x880,0x3330,
+0x3b1,0x342,0x3b9,0x391,0x342,0x399,0x391,0x342,0x345,0xc90,9,0x220,0x3b1,0x3b9,0x391,0x399,
+0x846,0x3b9,0x399,1,0x345,0x880,0x2220,0x1f74,0x3b9,0x1fca,0x399,0x1fca,0x345,0x890,9,0x220,
+0x3b7,0x3b9,0x397,0x399,0x880,0x2220,0x3ae,0x3b9,0x389,0x399,0x389,0x345,0x880,0x2220,0x3b7,0x342,
+0x397,0x342,0x397,0x342,0x880,0x3330,0x3b7,0x342,0x3b9,0x397,0x342,0x399,0x397,0x342,0x345,0xc90,
+9,0x220,0x3b7,0x3b9,0x397,0x399,0x880,0x3330,0x3b9,0x308,0x300,0x399,0x308,0x300,0x399,0x308,
+0x300,0x8c0,1,0x3330,0x3b9,0x308,0x301,0x399,0x308,0x301,0x399,0x308,0x301,0x390,0x880,0x2220,
+0x3b9,0x342,0x399,0x342,0x399,0x342,0x880,0x3330,0x3b9,0x308,0x342,0x399,0x308,0x342,0x399,0x308,
+0x342,0x880,0x3330,0x3c5,0x308,0x300,0x3a5,0x308,0x300,0x3a5,0x308,0x300,0x8c0,1,0x3330,0x3c5,
+0x308,0x301,0x3a5,0x308,0x301,0x3a5,0x308,0x301,0x3b0,0x880,0x2220,0x3c1,0x313,0x3a1,0x313,0x3a1,
+0x313,0x880,0x2220,0x3c5,0x342,0x3a5,0x342,0x3a5,0x342,0x880,0x3330,0x3c5,0x308,0x342,0x3a5,0x308,
+0x342,0x3a5,0x308,0x342,0x880,0x2220,0x1f7c,0x3b9,0x1ffa,0x399,0x1ffa,0x345,0x890,9,0x220,0x3c9,
+0x3b9,0x3a9,0x399,0x880,0x2220,0x3ce,0x3b9,0x38f,0x399,0x38f,0x345,0x880,0x2220,0x3c9,0x342,0x3a9,
+0x342,0x3a9,0x342,0x880,0x3330,0x3c9,0x342,0x3b9,0x3a9,0x342,0x399,0x3a9,0x342,0x345,0xc90,9,
+0x220,0x3c9,0x3b9,0x3a9,0x399,0xc50,0x1d5d,1,0x3a9,0xc50,0x20bf,1,0x4b,0xc50,0x2046,1,
+0xc5,0xc10,0x29f7,0xc10,0xee6,0xc10,0x29e7,0xc10,0x2a2b,0xc10,0x2a28,0xc10,0x2a1c,0xc10,0x29fd,0xc10,
+0x2a1f,0xc10,0x2a1e,0xc10,0x2a3f,0xc10,0x1c60,0x841,0xa64b,1,0x1c88,0x844,0xa64a,1,0x1c88,0xc10,
+0x8a04,0xc10,0xa528,0xc10,0xa544,0xc10,0xa54f,0xc10,0xa54b,0xc10,0xa541,0xc10,0xa512,0xc10,0xa52a,0xc10,
+0xa515,0x810,0x3a0,0xc10,0x3a0,0x806,0x13a0,0x13a0,0x806,0x13a1,0x13a1,0x806,0x13a2,0x13a2,0x806,0x13a3,
+0x13a3,0x806,0x13a4,0x13a4,0x806,0x13a5,0x13a5,0x806,0x13a6,0x13a6,0x806,0x13a7,0x13a7,0x806,0x13a8,0x13a8,
+0x806,0x13a9,0x13a9,0x806,0x13aa,0x13aa,0x806,0x13ab,0x13ab,0x806,0x13ac,0x13ac,0x806,0x13ad,0x13ad,0x806,
+0x13ae,0x13ae,0x806,0x13af,0x13af,0x806,0x13b0,0x13b0,0x806,0x13b1,0x13b1,0x806,0x13b2,0x13b2,0x806,0x13b3,
+0x13b3,0x806,0x13b4,0x13b4,0x806,0x13b5,0x13b5,0x806,0x13b6,0x13b6,0x806,0x13b7,0x13b7,0x806,0x13b8,0x13b8,
+0x806,0x13b9,0x13b9,0x806,0x13ba,0x13ba,0x806,0x13bb,0x13bb,0x806,0x13bc,0x13bc,0x806,0x13bd,0x13bd,0x806,
+0x13be,0x13be,0x806,0x13bf,0x13bf,0x806,0x13c0,0x13c0,0x806,0x13c1,0x13c1,0x806,0x13c2,0x13c2,0x806,0x13c3,
+0x13c3,0x806,0x13c4,0x13c4,0x806,0x13c5,0x13c5,0x806,0x13c6,0x13c6,0x806,0x13c7,0x13c7,0x806,0x13c8,0x13c8,
+0x806,0x13c9,0x13c9,0x806,0x13ca,0x13ca,0x806,0x13cb,0x13cb,0x806,0x13cc,0x13cc,0x806,0x13cd,0x13cd,0x806,
+0x13ce,0x13ce,0x806,0x13cf,0x13cf,0x806,0x13d0,0x13d0,0x806,0x13d1,0x13d1,0x806,0x13d2,0x13d2,0x806,0x13d3,
+0x13d3,0x806,0x13d4,0x13d4,0x806,0x13d5,0x13d5,0x806,0x13d6,0x13d6,0x806,0x13d7,0x13d7,0x806,0x13d8,0x13d8,
+0x806,0x13d9,0x13d9,0x806,0x13da,0x13da,0x806,0x13db,0x13db,0x806,0x13dc,0x13dc,0x806,0x13dd,0x13dd,0x806,
+0x13de,0x13de,0x806,0x13df,0x13df,0x806,0x13e0,0x13e0,0x806,0x13e1,0x13e1,0x806,0x13e2,0x13e2,0x806,0x13e3,
+0x13e3,0x806,0x13e4,0x13e4,0x806,0x13e5,0x13e5,0x806,0x13e6,0x13e6,0x806,0x13e7,0x13e7,0x806,0x13e8,0x13e8,
+0x806,0x13e9,0x13e9,0x806,0x13ea,0x13ea,0x806,0x13eb,0x13eb,0x806,0x13ec,0x13ec,0x806,0x13ed,0x13ed,0x806,
+0x13ee,0x13ee,0x806,0x13ef,0x13ef,0x880,0x2220,0x66,0x66,0x46,0x46,0x46,0x66,0x880,0x2220,0x66,
+0x69,0x46,0x49,0x46,0x69,0x880,0x2220,0x66,0x6c,0x46,0x4c,0x46,0x6c,0x880,0x3330,0x66,
+0x66,0x69,0x46,0x46,0x49,0x46,0x66,0x69,0x880,0x3330,0x66,0x66,0x6c,0x46,0x46,0x4c,
+0x46,0x66,0x6c,0x8c0,1,0x2220,0x73,0x74,0x53,0x54,0x53,0x74,0xfb06,0x8c0,1,0x2220,
+0x73,0x74,0x53,0x54,0x53,0x74,0xfb05,0x880,0x2220,0x574,0x576,0x544,0x546,0x544,0x576,0x880,
+0x2220,0x574,0x565,0x544,0x535,0x544,0x565,0x880,0x2220,0x574,0x56b,0x544,0x53b,0x544,0x56b,0x880,
+0x2220,0x57e,0x576,0x54e,0x546,0x54e,0x576,0x880,0x2220,0x574,0x56d,0x544,0x53d,0x544,0x56d
 };
 
 static const uint16_t ucase_props_unfold[370]={
@@ -910,19 +913,19 @@ static const UCaseProps ucase_props_singleton={
   ucase_props_unfold,
   {
     ucase_props_trieIndex,
-    ucase_props_trieIndex+3228,
+    ucase_props_trieIndex+3248,
     NULL,
-    3228,
-    8492,
+    3248,
+    8816,
     0x188,
-    0xd18,
+    0xd2c,
     0x0,
     0x0,
     0xe0800,
-    0x2dc4,
+    0x2f1c,
     NULL, 0, FALSE, FALSE, 0, NULL
   },
-  { 3,0,0,0 }
+  { 4,0,0,0 }
 };
 
 #endif  // INCLUDED_FROM_UCASE_CPP
diff --git a/deps/icu-small/source/common/uchar_props_data.h b/deps/icu-small/source/common/uchar_props_data.h
index 868631131c8643..e9c231908e8288 100644
--- a/deps/icu-small/source/common/uchar_props_data.h
+++ b/deps/icu-small/source/common/uchar_props_data.h
@@ -11,145 +11,145 @@
 
 #ifdef INCLUDED_FROM_UCHAR_C
 
-static const UVersionInfo dataVersion={0xa,0,0,0};
+static const UVersionInfo dataVersion={0xb,0,0,0};
 
-static const uint16_t propsTrie_index[21148]={
-0x45c,0x464,0x46c,0x474,0x48c,0x494,0x49c,0x4a4,0x4ac,0x4b4,0x4ba,0x4c2,0x4ca,0x4d2,0x4da,0x4e2,
-0x4e8,0x4f0,0x4f8,0x500,0x503,0x50b,0x513,0x51b,0x523,0x52b,0x527,0x52f,0x537,0x53f,0x544,0x54c,
-0x554,0x55c,0x560,0x568,0x570,0x578,0x580,0x588,0x584,0x58c,0x591,0x599,0x59f,0x5a7,0x5af,0x5b7,
-0x5bf,0x5c7,0x5cf,0x5d7,0x5dc,0x5e4,0x5e7,0x5ef,0x5f7,0x5ff,0x605,0x60d,0x60c,0x614,0x61c,0x624,
-0x634,0x62c,0x63c,0x644,0x47c,0x654,0x65c,0x64c,0x66c,0x66e,0x676,0x664,0x686,0x68c,0x694,0x67e,
-0x6a4,0x6aa,0x6b2,0x69c,0x6c2,0x6c8,0x6d0,0x6ba,0x6e0,0x6e6,0x6ee,0x6d8,0x6fe,0x706,0x70e,0x6f6,
-0x71e,0x724,0x72c,0x716,0x73c,0x742,0x74a,0x734,0x75a,0x75f,0x767,0x752,0x777,0x77e,0x786,0x76f,
-0x608,0x78e,0x796,0x47c,0x79e,0x7a6,0x7ae,0x47c,0x7b6,0x7be,0x7c6,0x7cb,0x7d3,0x7da,0x7e2,0x47c,
-0x5c7,0x7ea,0x7f2,0x7fa,0x802,0x554,0x812,0x80a,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x818,0x5c7,0x820,0x816,0x828,0x5c7,0x824,0x5c7,0x82e,0x836,0x83e,0x554,0x554,0x846,
-0x84e,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x853,0x85b,0x5c7,0x5c7,0x863,0x86b,0x873,0x87b,0x883,0x5c7,0x88b,0x893,0x89b,
-0x8ab,0x5c7,0x8b3,0x8b5,0x8bd,0x8a3,0x5c7,0x8c0,0x8d4,0x8c8,0x8d0,0x8dc,0x5c7,0x8e4,0x8ea,0x8f2,
-0x8fa,0x5c7,0x90a,0x912,0x91a,0x902,0x47c,0x47c,0x92a,0x92d,0x935,0x922,0x945,0x93d,0x5c7,0x94c,
-0x5c7,0x95b,0x954,0x963,0x96b,0x47c,0x973,0x97b,0x4fc,0x983,0x986,0x98c,0x993,0x986,0x523,0x99b,
-0x4ac,0x4ac,0x4ac,0x4ac,0x9a3,0x4ac,0x4ac,0x4ac,0x9b3,0x9bb,0x9c3,0x9cb,0x9d3,0x9d7,0x9df,0x9ab,
-0x9f7,0x9ff,0x9e7,0x9ef,0xa07,0xa0f,0xa17,0xa1f,0xa37,0xa27,0xa2f,0xa3f,0xa47,0xa56,0xa5b,0xa4e,
-0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0xa6b,0xa73,0x8f2,0xa76,0xa7e,0xa85,0xa8a,0xa92,
-0x8f2,0xa99,0xa98,0xaa9,0xaac,0x8f2,0x8f2,0xaa1,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0xabb,0xac3,0xab3,
-0x8f2,0x8f2,0x8f2,0xac8,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0xace,0xad6,0x8f2,0xade,0xae5,
-0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0xa63,0xa63,0xa63,0xa63,0xaed,0xa63,0xaf4,0xafb,
-0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0xa63,0x8f2,0xb03,0xb0a,0xb0e,0xb14,0xb1a,0xb22,0xb27,
-0x554,0xb37,0xb2f,0xb3f,0x4ac,0x4ac,0x4ac,0xb47,0x4fc,0xb4f,0x5c7,0xb55,0xb65,0xb5d,0xb5d,0x523,
-0xb6d,0xb75,0xb7d,0x47c,0xb85,0x8f2,0x8f2,0xb8c,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0xb94,0xb9a,
-0xbaa,0xba2,0x608,0x5c7,0xbb2,0x84e,0x5c7,0xbba,0xbc2,0xbc7,0x5c7,0x5c7,0xbcc,0x5b3,0x8f2,0xbd3,
-0xa93,0xbdb,0xbe1,0x8f2,0xbdb,0xbe9,0x8f2,0xa93,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,
-0xbf1,0x5c7,0x5c7,0x5c7,0xbf9,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0xbff,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc04,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x8c0,0x8f2,0x8f2,
-0xc0c,0x5c7,0xc0f,0x5c7,0xc17,0xc1d,0xc25,0xc2d,0xc32,0x5c7,0x5c7,0xc36,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc3d,0x5c7,0xc44,0xc4a,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc52,0x5c7,0x5c7,0x5c7,0xc5a,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc5c,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc63,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0xc6a,0x5c7,0x5c7,0x5c7,0xc71,0xc79,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc7e,0x5c7,0x5c7,0xc86,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc8a,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc8d,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc90,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0xc96,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0xc9e,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0xca3,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xca8,0x5c7,0x5c7,0x5c7,0xcad,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0xcb5,0xcbc,0xcc0,0x5c7,0x5c7,0x5c7,0xcc7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x644,
-0xcd5,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0xccd,0x8f2,0xcdd,0x963,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0xce2,0xcea,0x4ac,0xcfa,0xcf2,0x5c7,0x5c7,0xd02,0xd0a,0xd1a,0x4ac,0xd1f,0xd27,0xd2d,0x47c,0xd12,
-0xd35,0xd3d,0x5c7,0xd45,0xd55,0xd58,0xd4d,0xd60,0x61c,0xd68,0xd6f,0xd77,0x66c,0xd87,0xd7f,0xd8f,
-0x5c7,0xd97,0xd9f,0xda7,0x5c7,0xdaf,0xdb7,0xdbf,0xdc7,0xdcf,0xdd3,0xddb,0x4fc,0x4fc,0x5c7,0xde3,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xdeb,0xdf2,0x8b4,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,
-0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0x5c7,0x5c7,0x5c7,0xe0a,0x5c7,0xcc8,0xe11,0xe16,
-0x5c7,0x5c7,0x5c7,0xe1e,0x5c7,0x5c7,0x8bf,0x47c,0xe34,0xe24,0xe2c,0x5c7,0x5c7,0xe3c,0xe44,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xe49,0xe51,0x5c7,0xe55,0x5c7,0xe5b,0xe5f,
-0xe67,0xe6f,0xe76,0xe7e,0x5c7,0x5c7,0x5c7,0xe84,0xe9c,0x46c,0xea4,0xeac,0xeb1,0x8d4,0xe8c,0xe94,
-0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,
-0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,0xdfa,
-0x11f0,0x11f0,0x1230,0x1270,0x12b0,0x12e8,0x1328,0x1368,0x13a0,0x13e0,0x140c,0x144c,0x148c,0x149c,0x14dc,0x1510,
-0x1550,0x1580,0x15c0,0x1600,0x1610,0x1644,0x167c,0x16bc,0x16fc,0x173c,0x1770,0x179c,0x17dc,0x1814,0x1830,0x1870,
-0xa80,0xac0,0xb00,0xb3b,0xb7b,0xa40,0xbbb,0xa40,0xbdd,0xa40,0xa40,0xa40,0xa40,0xc1d,0x1db,0x1db,
-0xc5d,0xc9d,0xa40,0xa40,0xa40,0xa40,0xcdd,0xcfd,0xa40,0xa40,0xd3d,0xd7d,0xdbd,0xdfd,0xe3d,0xe7d,
-0xebd,0xef4,0x1db,0x1db,0xf18,0xf4c,0x1db,0xf74,0x1db,0x1db,0x1db,0x1db,0xfa1,0x1db,0x1db,0x1db,
-0x1db,0x1db,0x1db,0x1db,0xfb5,0x1db,0xfed,0x102d,0x1db,0x1038,0x1db,0x1db,0x1db,0x106e,0xa40,0x10ae,
+static const uint16_t propsTrie_index[21452]={
+0x45d,0x465,0x46d,0x475,0x48d,0x495,0x49d,0x4a5,0x4ad,0x4b5,0x4bb,0x4c3,0x4cb,0x4d3,0x4db,0x4e3,
+0x4e9,0x4f1,0x4f9,0x501,0x504,0x50c,0x514,0x51c,0x524,0x52c,0x528,0x530,0x538,0x540,0x545,0x54d,
+0x555,0x55d,0x561,0x569,0x571,0x579,0x581,0x589,0x585,0x58d,0x592,0x59a,0x5a0,0x5a8,0x5b0,0x5b8,
+0x5c0,0x5c8,0x5d0,0x5d8,0x5dd,0x5e5,0x5e8,0x5f0,0x5f8,0x600,0x606,0x60e,0x60d,0x615,0x61d,0x625,
+0x635,0x62d,0x63d,0x645,0x47d,0x655,0x65d,0x64d,0x66d,0x66f,0x677,0x665,0x687,0x68d,0x695,0x67f,
+0x6a5,0x6ab,0x6b3,0x69d,0x6c3,0x6c9,0x6d1,0x6bb,0x6e1,0x6e7,0x6ef,0x6d9,0x6ff,0x707,0x70f,0x6f7,
+0x71f,0x725,0x72d,0x717,0x73d,0x743,0x74b,0x735,0x75b,0x760,0x768,0x753,0x778,0x77f,0x787,0x770,
+0x609,0x78f,0x797,0x47d,0x79f,0x7a7,0x7af,0x47d,0x7b7,0x7bf,0x7c7,0x7cc,0x7d4,0x7db,0x7e3,0x47d,
+0x5c8,0x7eb,0x7f3,0x7fb,0x803,0x555,0x813,0x80b,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x81b,0x5c8,0x823,0x827,0x82f,0x5c8,0x835,0x5c8,0x83b,0x843,0x84b,0x555,0x555,0x853,
+0x85b,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x860,0x868,0x5c8,0x5c8,0x870,0x878,0x880,0x888,0x890,0x5c8,0x898,0x8a0,0x8a8,
+0x8b8,0x5c8,0x8c0,0x8c2,0x8ca,0x8b0,0x5c8,0x8cd,0x8e1,0x8d5,0x8dd,0x8e9,0x5c8,0x8f1,0x8f7,0x8ff,
+0x907,0x5c8,0x917,0x91f,0x927,0x90f,0x47d,0x47d,0x937,0x93a,0x942,0x92f,0x952,0x94a,0x5c8,0x959,
+0x5c8,0x968,0x961,0x970,0x978,0x97c,0x984,0x98c,0x4fd,0x994,0x997,0x99d,0x9a4,0x997,0x524,0x9ac,
+0x4ad,0x4ad,0x4ad,0x4ad,0x9b4,0x4ad,0x4ad,0x4ad,0x9c4,0x9cc,0x9d4,0x9dc,0x9e4,0x9e8,0x9f0,0x9bc,
+0xa08,0xa10,0x9f8,0xa00,0xa18,0xa20,0xa28,0xa30,0xa48,0xa38,0xa40,0xa50,0xa58,0xa67,0xa6c,0xa5f,
+0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa7c,0xa84,0x8ff,0xa87,0xa8f,0xa96,0xa9b,0xaa3,
+0x8ff,0xaaa,0xaa9,0xaba,0xabd,0x8ff,0x8ff,0xab2,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0xacc,0xad4,0xac4,
+0x8ff,0x8ff,0x8ff,0xad9,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0xadf,0xae7,0x8ff,0xaef,0xaf6,
+0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0xa74,0xa74,0xa74,0xa74,0xafe,0xa74,0xb05,0xb0c,
+0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0x8ff,0xb14,0xb1b,0xb1f,0xb25,0x8ff,0xb2b,0xaa4,
+0x555,0xb3b,0xb33,0xb43,0x4ad,0x4ad,0x4ad,0xb4b,0x4fd,0xb53,0x5c8,0xb59,0xb69,0xb61,0xb61,0x524,
+0xb71,0xb79,0xb81,0x47d,0xb89,0x8ff,0x8ff,0xb90,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0xb98,0xb9e,
+0xbae,0xba6,0x609,0x5c8,0xbb6,0x85b,0x5c8,0xbbe,0xbc6,0xbca,0x5c8,0x5c8,0xbcf,0xbd7,0x8ff,0xbdf,
+0xaa4,0xbe7,0xbed,0x8ff,0xbe7,0xbf5,0x8ff,0xaa4,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,
+0xbfd,0x5c8,0x5c8,0x5c8,0xc05,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0xc0b,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc10,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x8cd,0x8ff,0x8ff,
+0xc18,0x5c8,0xc1b,0x5c8,0xc23,0xc29,0xc31,0xc39,0xc3e,0x5c8,0x5c8,0xc42,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc49,0x5c8,0xc50,0xc56,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc5e,0x5c8,0x5c8,0x5c8,0xc66,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc68,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc6f,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0xc76,0x5c8,0x5c8,0x5c8,0xc7d,0xc85,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc8a,0x5c8,0x5c8,0xc92,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc96,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc99,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xc9c,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0xca2,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0xcaa,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0xcaf,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xcb4,0x5c8,0x5c8,0x5c8,0xcb9,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0xcc1,0xcc8,0xccc,0x5c8,0x5c8,0x5c8,0xcd3,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xcd9,
+0xce9,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0xce1,0x8ff,0xcf1,0x970,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0xcf6,0xcfe,0x4ad,0xd0e,0xd06,0x5c8,0x5c8,0xd16,0xd1e,0xd2e,0x4ad,0xd33,0xd3b,0xd41,0x47d,0xd26,
+0xd49,0xd51,0x5c8,0xd59,0xd69,0xd6c,0xd61,0xd74,0x61d,0xd7c,0xd83,0x8c1,0x66d,0xd93,0xd8b,0xd9b,
+0x5c8,0xda3,0xdab,0xdb3,0x5c8,0xdbb,0xdc3,0xdcb,0xdd3,0xddb,0xddf,0xde7,0x4fd,0x4fd,0x5c8,0xdef,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xdf7,0xe03,0xdfb,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,
+0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0x5c8,0x5c8,0x5c8,0xe1b,0x5c8,0xcd4,0xe22,0xe27,
+0x5c8,0x5c8,0x5c8,0xe2f,0x5c8,0x5c8,0x8cc,0x47d,0xe45,0xe35,0xe3d,0x5c8,0x5c8,0xe4d,0xe55,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xe5a,0xe62,0x5c8,0xe66,0x5c8,0xe6c,0xe70,
+0xe78,0xe80,0xe87,0xe8f,0x5c8,0x5c8,0x5c8,0xe95,0xead,0x46d,0xeb5,0xebd,0xec2,0x8e1,0xe9d,0xea5,
+0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,
+0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,0xe0b,
+0x11f4,0x11f4,0x1234,0x1274,0x12b4,0x12ec,0x132c,0x136c,0x13a4,0x13e4,0x1410,0x1450,0x1490,0x14a0,0x14e0,0x1514,
+0x1554,0x1584,0x15c4,0x1604,0x1614,0x1648,0x1680,0x16c0,0x1700,0x1740,0x1774,0x17a0,0x17e0,0x1818,0x1834,0x1874,
+0xa80,0xac0,0xb00,0xb40,0xb80,0xa40,0xbc0,0xa40,0xbe2,0xa40,0xa40,0xa40,0xa40,0xc22,0x1db,0x1db,
+0xc62,0xca2,0xa40,0xa40,0xa40,0xa40,0xce2,0xd02,0xa40,0xa40,0xd42,0xd82,0xdc2,0xe02,0xe42,0xe82,
+0xec2,0xef9,0x1db,0x1db,0xf1d,0xf51,0x1db,0xf79,0x1db,0x1db,0x1db,0x1db,0xfa6,0x1db,0x1db,0x1db,
+0x1db,0x1db,0x1db,0x1db,0xfba,0x1db,0xff2,0x1032,0x1db,0x103d,0x1db,0x1db,0x1db,0x1073,0xa40,0x10b3,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
@@ -172,564 +172,565 @@ static const uint16_t propsTrie_index[21148]={
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0x10ee,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
+0x10f3,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
 0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,
-0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x112e,
+0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x1133,
 0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,
-0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x112e,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0xeb9,0xec0,0xec8,0x47c,0x5c7,0x5c7,0x5c7,0x5b3,0xed8,0xed0,0xeef,0xee0,0xee7,0xef7,0xb81,0xeff,
-0x47c,0x47c,0x47c,0x47c,0xd77,0x5c7,0xf07,0xf0f,0x5c7,0xf17,0xf1f,0xf23,0xf2b,0x5c7,0xf33,0x47c,
-0x554,0x55e,0xf3b,0x5c7,0xf3f,0xf47,0xf57,0xf4f,0x5c7,0xf5f,0x5c7,0xf66,0x47c,0x47c,0x47c,0x47c,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xb65,0x8c0,0xe5b,0x47c,0x47c,0x47c,0x47c,
-0xf76,0xf6e,0xf79,0xf81,0x8d4,0xf89,0x47c,0xf91,0xf99,0xfa1,0x47c,0x47c,0x5c7,0xfb1,0xfb9,0xfa9,
-0xfc9,0xfd0,0xfc1,0xfd8,0xfe0,0x47c,0xff0,0xfe8,0x5c7,0xff3,0xffb,0x1003,0x100b,0x1013,0x47c,0x47c,
-0x5c7,0x5c7,0x101b,0x47c,0x554,0x1023,0x4fc,0x102b,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x1033,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x1043,0x5fd,0x104b,0x103b,0x945,0x1053,0x105b,0x1061,0x1079,0x1069,0x1071,0x107d,0x945,0x108d,0x1085,0x1095,
-0x10a5,0x109d,0x47c,0x47c,0x10ac,0x10b4,0x61f,0x10bc,0x10cc,0x6c8,0x10d4,0x10c4,0x47c,0x47c,0x47c,0x47c,
-0x5c7,0x10dc,0x10e4,0x47c,0x5c7,0x10ec,0x10f4,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x10fc,0x1104,0x47c,
-0x5c7,0x110c,0x1114,0x111c,0x5c7,0x112c,0x1124,0x47c,0x113c,0x1134,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x554,0x4fc,0x1144,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x115c,0x114c,0x1154,0x5c7,0x116c,
-0x1164,0x5c7,0x1174,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x118a,0x118f,0x117c,0x1184,0x119f,
-0x1197,0x47c,0x47c,0x11ae,0x11b2,0x11a6,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x8bf,0x47c,0x47c,0x47c,0x11c2,0x11ca,0x11d2,0x11ba,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x11da,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x11e2,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x11e4,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1174,0x8d4,
-0x11ec,0x47c,0x47c,0xe51,0x11f4,0x5c7,0x1204,0x120c,0x1214,0x11fc,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x121c,0x1221,0x1229,0x47c,0x47c,0x1231,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1239,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x1241,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x8d4,0x47c,0x47c,0xe51,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x8b4,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,
-0x1249,0x124e,0x1256,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x8f2,0x8f2,0x8f2,
-0x8f2,0x8f2,0x8f2,0x8f2,0xb94,0x8f2,0x125e,0x8f2,0x1265,0x126d,0x1273,0x8f2,0x1279,0x8f2,0x8f2,0x1281,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x8f2,0x8f2,0xa95,0x1289,0x47c,0x47c,0x47c,0x47c,0x1299,0x12a0,0x12a5,
-0x12ab,0x12b3,0x12bb,0x12c3,0x129d,0x12cb,0x12d3,0x12db,0x12e0,0x12b2,0x1299,0x12a0,0x129c,0x12ab,0x12e8,0x129a,
-0x12eb,0x129d,0x12f3,0x12fb,0x1303,0x130a,0x12f6,0x12fe,0x1306,0x130d,0x12f9,0x1315,0x1291,0x8f2,0x8f2,0x8f2,
-0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x523,0x1325,0x523,
-0x132c,0x1333,0x131d,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x133a,0x1342,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x134a,0x47c,0x554,0x135a,0x1352,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x136a,0x1372,0x137a,
-0x1382,0x138a,0x1392,0x47c,0x1362,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x8f2,0x139a,0x8f2,
-0x8f2,0xb8c,0x139f,0x13a3,0xb94,0x13ab,0x13b0,0x8f2,0x139a,0x8f2,0x1278,0x47c,0x13b8,0x13c0,0x13c4,0x13cc,
-0x13d4,0x47c,0x47c,0x47c,0x47c,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x13dc,0x8f2,0x8f2,0x8f2,
-0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,0x8f2,
-0x8f2,0x8f2,0x8f2,0x13e4,0x13ec,0x8f2,0x8f2,0x8f2,0xb8c,0x8f2,0x8f2,0x13e4,0x47c,0x139a,0x8f2,0x13f4,
-0x8f2,0x13fc,0xb96,0x47c,0x47c,0x139a,0xa93,0x1401,0x1406,0x140e,0x47c,0x1416,0xa99,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x141e,0x5c7,0x5c7,
-0x1425,0x5c7,0x5c7,0x5c7,0x142d,0x5c7,0x1435,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xc6e,0x5c7,0x5c7,
-0x143d,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1445,0x144d,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0xcad,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1454,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x145b,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x1462,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xb65,0x47c,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1466,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xf3f,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x146e,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,
-0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x1476,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x5c7,0x5c7,
-0x5c7,0x5c7,0x147e,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0x5c7,0xf3f,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x148e,0x1486,
-0x1486,0x1486,0x47c,0x47c,0x47c,0x47c,0x523,0x523,0x523,0x523,0x523,0x523,0x523,0x1496,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,
-0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0x47c,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,
-0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0xe02,0x149e,0x45b,0x45b,
+0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x700,0x1133,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0xeca,0xed1,0xed9,0x47d,0x5c8,0x5c8,0x5c8,0xbd7,0xee9,0xee1,0xf00,0xef1,0xef8,0xf08,0xb85,0xf10,
+0x47d,0x47d,0x47d,0x47d,0x8c1,0x5c8,0xf18,0xf20,0x5c8,0xf28,0xf30,0xf34,0xf3c,0x5c8,0xf44,0x47d,
+0x555,0x55f,0xf4c,0x5c8,0xf50,0xf58,0xf68,0xf60,0x5c8,0xf70,0x5c8,0xf77,0x47d,0x47d,0x47d,0x47d,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xb69,0x8cd,0xe6c,0x47d,0x47d,0x47d,0x47d,
+0xf87,0xf7f,0xf8a,0xf92,0x8e1,0xf9a,0x47d,0xfa2,0xfaa,0xfb2,0x47d,0x47d,0x5c8,0xfc2,0xfca,0xfba,
+0xfda,0xfe1,0xfd2,0xfe9,0xff1,0x47d,0x1001,0xff9,0x5c8,0x1004,0x100c,0x1014,0x101c,0x1024,0x47d,0x47d,
+0x5c8,0x5c8,0x102c,0x47d,0x555,0x1034,0x4fd,0x103c,0x5c8,0x1044,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x104c,0x47d,0x47d,0x47d,0x47d,0x1054,0x105c,0x1063,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x1073,0x5fe,0x107b,0x106b,0x952,0x1083,0x108b,0x1091,0x10a9,0x1099,0x10a1,0x10ad,0x952,0x10bd,0x10b5,0x10c5,
+0x10d5,0x10cd,0x47d,0x47d,0x10dc,0x10e4,0x620,0x10ec,0x10fc,0x1102,0x110a,0x10f4,0x47d,0x47d,0x47d,0x47d,
+0x5c8,0x1112,0x111a,0x47d,0x5c8,0x1122,0x112a,0x47d,0x47d,0x47d,0x47d,0x47d,0x5c8,0x1132,0x113a,0x47d,
+0x5c8,0x1142,0x114a,0x1152,0x5c8,0x1162,0x115a,0x47d,0x83b,0x116a,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x5c8,0x1172,0x47d,0x47d,0x47d,0x555,0x4fd,0x117a,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x1192,0x1182,0x118a,0x5c8,0x11a2,0x119a,0x5c8,0x8c2,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x11b8,0x11bd,0x11aa,0x11b2,0x11cd,0x11c5,0x47d,0x47d,0x11dc,0x11e0,0x11d4,0x11f0,0x11e8,0x115a,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x11f4,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x8cc,0x47d,0x47d,0x47d,
+0x1204,0x120c,0x1214,0x11fc,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x121c,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x1224,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x1226,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x8c2,0x8e1,0x122e,0x47d,0x47d,0xe62,0x1236,0x5c8,0x123e,0x1246,0x124e,0xcd9,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x555,0x4fd,0x1256,0x47d,0x47d,0x47d,0x5c8,0x5c8,0x125e,0x1263,0x126b,0x47d,
+0x47d,0x1273,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x127b,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x1283,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x8e1,0x47d,0x47d,0xe62,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xdfb,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x128b,0x1290,0x1298,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0xb98,0x8ff,0x12a0,0x8ff,0x12a7,0x12af,0x12b5,
+0x8ff,0x12bb,0x8ff,0x8ff,0x12c3,0x47d,0x47d,0x47d,0x47d,0x12cb,0x8ff,0x8ff,0xaa6,0x12d3,0x47d,0x47d,
+0x47d,0x47d,0x12e3,0x12ea,0x12ef,0x12f5,0x12fd,0x1305,0x130d,0x12e7,0x1315,0x131d,0x1325,0x132a,0x12fc,0x12e3,
+0x12ea,0x12e6,0x12f5,0x1332,0x12e4,0x1335,0x12e7,0x133d,0x1345,0x134d,0x1354,0x1340,0x1348,0x1350,0x1357,0x1343,
+0x135f,0x12db,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,
+0x8ff,0x8ff,0x524,0x136f,0x524,0x1376,0x137d,0x1367,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x1384,0x138c,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x1394,0x47d,0x555,0x13a4,0x139c,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x13ac,0x13bc,0x13b4,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x13cc,0x13d4,0x13dc,0x13e4,0x13ec,0x13f4,0x47d,0x13c4,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x8ff,0x13fc,0x8ff,0x8ff,0xb90,0x1401,0x1405,0xb98,0x140d,0x8ff,0x8ff,0x13fc,0x8ff,0x12ba,
+0x47d,0x1415,0x141d,0x1421,0x1429,0x1431,0x47d,0x47d,0x47d,0x47d,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,
+0x8ff,0x1439,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,
+0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x8ff,0x1441,0x1449,0x8ff,0x8ff,0x8ff,0xb90,0x8ff,0x8ff,
+0x1451,0x47d,0x13fc,0x8ff,0x1459,0x8ff,0x1461,0xb9a,0x47d,0x47d,0x13fc,0xaa4,0x8ff,0x1465,0x8ff,0x146d,
+0x141d,0x8ff,0x47d,0x47d,0x47d,0xb9a,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x1475,0x5c8,0x5c8,0x147c,0x5c8,0x5c8,0x5c8,0x1484,0x5c8,0x148c,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0xc7a,0x5c8,0x5c8,0x1494,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x149c,0x14a4,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0xcb9,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x14ab,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x14b2,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x14b9,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0xb69,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x14bd,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0xf50,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x127f,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x14c2,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x5c8,0x5c8,0x5c8,0x5c8,0x14ca,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,0x5c8,
+0x5c8,0x5c8,0x5c8,0xf50,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x14da,0x14d2,0x14d2,0x14d2,0x47d,0x47d,0x47d,0x47d,0x524,0x524,0x524,0x524,0x524,
+0x524,0x524,0x14e2,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,0x47d,
+0x47d,0x47d,0x47d,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,0xe13,
+0xe13,0xe13,0x14ea,0x45c,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
 0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
-0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
-0xc,0x17,0x17,0x17,0x19,0x17,0x17,0x17,0x14,0x15,0x17,0x18,0x17,0x13,0x17,0x17,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0x18,0x18,0x18,0x17,
-0x17,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0x14,0x17,0x15,0x1a,0x16,
-0x1a,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,0x14,0x18,0x15,0x18,0xf,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0xf,0xf,0xf,0xf,0xc,0x17,0x17,0x17,0x19,0x17,0x17,0x17,0x14,0x15,0x17,0x18,
+0x17,0x13,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,
+0x18,0x18,0x18,0x17,0x17,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x14,
+0x17,0x15,0x1a,0x16,0x1a,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0x14,
+0x18,0x15,0x18,0xf,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
 0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
-0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
-0xc,0x17,0x19,0x19,0x19,0x19,0x1b,0x17,0x1a,0x1b,5,0x1c,0x18,0x10,0x1b,0x1a,
-0x1b,0x18,0x34b,0x38b,0x1a,2,0x17,0x17,0x1a,0x30b,5,0x1d,0x34cb,0x344b,0x3ccb,0x17,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0x18,1,1,1,1,1,1,1,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,0x18,2,2,2,2,2,2,2,2,
+0xf,0xf,0xf,0xf,0xc,0x17,0x19,0x19,0x19,0x19,0x1b,0x17,0x1a,0x1b,5,0x1c,
+0x18,0x10,0x1b,0x1a,0x1b,0x18,0x34b,0x38b,0x1a,2,0x17,0x17,0x1a,0x30b,5,0x1d,
+0x34cb,0x344b,0x3ccb,0x17,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0x18,1,1,1,1,
+1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,0x18,2,2,2,2,
+2,2,2,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,2,1,2,1,2,1,2,1,
-2,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,1,2,1,2,1,2,2,2,1,1,2,1,2,1,1,
-2,1,1,1,2,2,1,1,1,1,2,1,1,2,1,1,
-1,2,2,2,1,1,2,1,1,2,1,2,1,2,1,1,
-2,1,2,2,1,2,1,1,2,1,1,1,2,1,2,1,
-1,2,2,5,1,2,2,2,5,5,5,5,1,3,2,1,
-3,2,1,3,2,1,2,1,2,1,2,1,2,1,2,1,
+1,2,1,2,1,2,1,2,1,2,1,2,2,1,2,1,
 2,1,2,1,2,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,2,1,3,2,1,2,1,1,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
+1,2,1,2,1,1,2,1,2,1,2,2,2,1,1,2,
+1,2,1,1,2,1,1,1,2,2,1,1,1,1,2,1,
+1,2,1,1,1,2,2,2,1,1,2,1,1,2,1,2,
+1,2,1,1,2,1,2,2,1,2,1,1,2,1,1,1,
+2,1,2,1,1,2,2,5,1,2,2,2,5,5,5,5,
+1,3,2,1,3,2,1,3,2,1,2,1,2,1,2,1,
+2,1,2,1,2,1,2,1,2,2,1,2,1,2,1,2,
+1,2,1,2,1,2,1,2,1,2,1,2,2,1,3,2,
+1,2,1,1,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,2,2,2,2,2,2,1,1,2,1,1,2,
-2,1,2,1,1,1,1,2,1,2,1,2,1,2,1,2,
+1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
+1,2,1,2,1,2,1,2,2,2,2,2,2,2,1,1,
+2,1,1,2,2,1,2,1,1,1,1,2,1,2,1,2,
+1,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,5,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-5,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,4,4,4,0x1a,0x1a,
-0x1a,0x1a,4,4,4,4,4,4,4,4,4,4,4,4,0x1a,0x1a,
-0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,4,4,4,4,
-4,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,4,0x1a,4,0x1a,0x1a,0x1a,0x1a,0x1a,
-0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,6,6,6,6,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+4,4,0x1a,0x1a,0x1a,0x1a,4,4,4,4,4,4,4,4,4,4,
+4,4,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,
+4,4,4,4,4,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,4,0x1a,4,0x1a,
+0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,1,2,1,2,
-4,0x1a,1,2,0,0,4,2,2,2,0x17,1,0,0,0,0,
-0x1a,0x1a,1,0x17,1,1,1,0,1,0,1,1,2,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,
-1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,
-2,2,1,1,1,2,2,2,1,2,1,2,1,2,1,2,
+1,2,1,2,4,0x1a,1,2,0,0,4,2,2,2,0x17,1,
+0,0,0,0,0x1a,0x1a,1,0x17,1,1,1,0,1,0,1,1,
+2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0,1,1,1,1,1,1,1,1,1,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,1,2,2,1,1,1,2,2,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-2,2,2,2,1,2,0x18,1,2,1,1,2,2,1,1,1,
+1,2,1,2,2,2,2,2,1,2,0x18,1,2,1,1,2,
+2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
+1,2,1,2,1,2,0x1b,6,6,6,6,6,7,7,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,0x1b,6,6,6,6,6,7,7,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
+1,2,1,2,1,1,2,1,2,1,2,1,2,1,2,1,
+2,1,2,2,1,2,1,2,1,2,1,2,1,2,1,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,0,0,4,0x17,0x17,
-0x17,0x17,0x17,0x17,0,2,2,2,2,2,2,2,2,2,2,2,
+1,2,1,2,0,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,
+0,4,0x17,0x17,0x17,0x17,0x17,0x17,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,0,0x17,0x13,0,0,0x1b,0x1b,0x19,0,6,6,6,
+2,2,2,2,2,2,2,2,2,0x17,0x13,0,0,0x1b,0x1b,0x19,
+0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,0x13,6,0x17,6,6,0x17,
-6,6,0x17,6,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,0,0,0,0,5,5,5,0x17,
-0x17,0,0,0,0,0,0,0,0,0,0,0,0x10,0x10,0x10,0x10,
-0x10,0x10,0x18,0x18,0x18,0x17,0x17,0x19,0x17,0x17,0x1b,0x1b,6,6,6,6,
-6,6,6,6,6,6,6,0x17,0x10,0,0x17,0x17,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,4,5,5,5,
-5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0x17,0x17,5,5,6,5,5,5,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,0x13,6,
+0x17,6,6,0x17,6,6,0x17,6,0,0,0,0,0,0,0,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,5,
+5,5,5,0x17,0x17,0,0,0,0,0,0,0,0,0,0,0,
+0x10,0x10,0x10,0x10,0x10,0x10,0x18,0x18,0x18,0x17,0x17,0x19,0x17,0x17,0x1b,0x1b,
+6,6,6,6,6,6,6,6,6,6,6,0x17,0x10,0,0x17,0x17,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+4,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0x17,0x17,5,5,
+6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-0x17,5,6,6,6,6,6,6,6,0x10,0x1b,6,6,6,6,6,
-6,4,4,6,6,0x1b,6,6,6,6,5,5,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,5,0x1b,0x1b,5,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0x10,5,6,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,0,
-0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,0x17,5,6,6,6,6,6,6,6,0x10,0x1b,6,
+6,6,6,6,6,4,4,6,6,0x1b,6,6,6,6,5,5,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,5,0x1b,0x1b,5,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0x10,
+5,6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,
-6,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,5,5,5,5,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+6,6,6,0,0,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,
-6,6,6,6,4,4,0x1b,0x17,0x17,0x17,4,0,0,0,0,0,
-6,6,6,6,4,6,6,6,4,6,6,6,6,6,0,0,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,6,6,6,6,4,6,6,6,6,6,
+5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,
+6,6,6,6,6,5,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,6,6,6,0,0,0x17,0,
-5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,
+6,6,6,6,6,6,6,6,4,4,0x1b,0x17,0x17,0x17,4,0,
+0,6,0x19,0x19,6,6,6,6,4,6,6,6,4,6,6,6,
+6,6,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,6,6,6,6,4,6,
+6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,
+0,0,0x17,0,5,5,5,5,5,5,5,5,5,5,5,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-6,6,0x10,6,6,6,6,6,6,6,6,6,6,6,6,6,
+0,0,0,0,6,6,0x10,6,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,0,5,5,5,5,5,5,5,5,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,6,6,6,6,6,6,6,6,6,6,6,6,
-5,5,6,6,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
-0x17,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-6,6,6,8,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,6,8,6,5,8,8,8,6,6,6,6,6,6,6,
-6,8,8,8,8,6,8,8,5,6,6,6,6,6,6,6,
-5,5,5,5,5,5,5,5,5,5,6,6,0,0,0x49,0x89,
-0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,0x19,0x19,0x37cb,0x35cb,0x3fcb,0x34cb,
-0x3ccb,0x94b,0x1b,0x19,5,0x17,0,0,5,6,8,8,0,5,5,5,
-5,5,5,5,5,0,0,5,5,0,0,5,5,5,5,5,
+6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,
-5,0,5,0,0,0,5,5,5,5,0,0,6,5,8,8,
-8,6,6,6,6,0,0,8,8,0,0,8,8,6,5,0,
-0,0,0,0,0,0,0,8,0,0,0,0,5,5,0,5,
+5,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,6,6,6,6,6,6,6,6,6,
+6,6,6,6,5,5,6,6,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,0x17,4,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,6,6,6,8,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,6,8,6,5,8,8,8,6,6,6,
+6,6,6,6,6,8,8,8,8,6,8,8,5,6,6,6,
+6,6,6,6,5,5,5,5,5,5,5,5,5,5,6,6,
+0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,0x19,0x19,
+0x37cb,0x35cb,0x3fcb,0x34cb,0x3ccb,0x94b,0x1b,0x19,5,0x17,6,0,5,6,8,8,
+0,5,5,5,5,5,5,5,5,0,0,5,5,0,0,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,5,5,5,5,0,5,0,0,0,5,5,5,5,0,0,
+6,5,8,8,8,6,6,6,6,0,0,8,8,0,0,8,
+8,6,5,0,0,0,0,0,0,0,0,8,0,0,0,0,
+5,5,0,5,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,6,6,5,5,5,6,0x17,0,0,0,0,0,
+0,0,0,0,0,6,6,8,0,5,5,5,5,5,5,0,
+0,0,0,5,5,0,0,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,5,5,5,0,5,5,
+0,5,5,0,5,5,0,0,6,0,8,8,8,6,6,0,
+0,0,0,6,6,0,0,6,6,6,0,0,0,6,0,0,
+0,0,0,0,0,5,5,5,5,0,5,0,5,5,6,6,
+0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x19,0,0,
+0,0,0,0,0,5,6,6,6,6,6,6,0,6,6,8,
+0,5,5,5,5,5,5,5,5,5,0,5,5,5,0,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,5,5,5,5,0,5,5,0,5,5,5,5,5,0,0,
+6,5,8,8,8,6,6,6,6,6,0,6,6,8,0,8,
+8,6,0,0,5,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,5,5,6,6,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,0x1b,5,0x34cb,0x344b,0x3ccb,0x37cb,0x35cb,0x3fcb,0,0,0,0,
+0,0,0,0,0,6,8,8,0,5,5,5,5,5,5,5,
+5,0,0,5,5,0,0,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,5,5,5,0,5,5,
+0,5,5,5,5,5,0,0,6,5,8,6,8,6,6,6,
+6,0,0,8,8,0,0,8,8,6,0,0,0,0,0,0,
+0,0,6,8,0,0,0,0,5,5,0,5,0,0,0,0,
+0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0x1e4b,0x784b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x19,0x1b,0,0,0,0,0,0,0,6,5,
+0,5,5,5,5,5,5,0,0,0,5,5,5,0,5,5,
+5,5,0,0,0,5,5,0,5,0,5,5,0,0,0,5,
+5,0,0,0,5,5,5,0,0,0,5,5,5,5,5,5,
+5,5,5,5,5,5,0,0,0,0,8,8,6,8,8,0,
+0,0,8,8,8,0,8,8,8,6,0,0,5,0,0,0,
+0,0,0,8,0,0,0,0,0,0,0,0,5,5,6,6,
+0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,
+0,0,0,0,0x54b,0x58b,0x5cb,0x60b,0x58b,0x5cb,0x60b,0x1b,6,8,8,8,
+6,5,5,5,5,5,5,5,5,0,5,5,5,0,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
+0,5,6,6,6,8,8,8,8,0,6,6,6,0,6,6,
+6,6,0,0,0,0,0,0,0,6,6,0,5,5,5,0,
+0,0,0,0,5,5,6,6,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,0,5,5,0,0,0,0,0,0,0,0,0,
+0,0,0,0,5,6,8,8,0x17,5,5,5,5,5,5,5,
+5,0,5,5,5,0,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,5,5,5,5,5,5,
+0,5,5,5,5,5,0,0,6,5,8,6,8,8,8,8,
+8,0,6,8,8,0,8,8,6,6,0,0,0,0,0,0,
+0,8,8,0,0,0,0,0,0,0,5,0,5,5,6,6,
+0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0x1e4b,0x784b,0x34cb,
+0x344b,0x3ccb,0x37cb,0x35cb,0x3fcb,0x1b,5,5,5,5,5,5,6,6,8,8,
+0,5,5,5,5,5,5,5,5,0,5,5,5,0,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,6,6,5,8,8,
+8,6,6,6,6,0,8,8,8,0,8,8,8,6,5,0x1b,
+0,0,0,0,5,5,5,8,0xcc0b,0xca0b,0xcb4b,0xc90b,0x364b,0xc94b,0x350b,5,
 0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
-6,6,5,5,5,6,0,0,0,0,0,0,0,0,0,0,
-0,6,6,8,0,5,5,5,5,5,5,0,0,0,0,5,
-5,0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,5,5,5,5,5,5,5,0,5,5,0,5,5,0,
-5,5,0,0,6,0,8,8,8,6,6,0,0,0,0,6,
-6,0,0,6,6,6,0,0,0,6,0,0,0,0,0,0,
-0,5,5,5,5,0,5,0,5,5,6,6,0,0,0x49,0x89,
-0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x19,0,0,0,0,0,0,
-0,5,6,6,6,6,6,6,0,6,6,8,0,5,5,5,
-5,5,5,5,5,5,0,5,5,5,0,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,
-5,0,5,5,0,5,5,5,5,5,0,0,6,5,8,8,
-8,6,6,6,6,6,0,6,6,8,0,8,8,6,0,0,
-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-5,5,6,6,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
-0x1b,5,0x34cb,0x344b,0x3ccb,0x37cb,0x35cb,0x3fcb,0,0,0,0,0,0,0,0,
-0,6,8,8,0,5,5,5,5,5,5,5,5,0,0,5,
-5,0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,5,5,5,5,5,5,5,0,5,5,0,5,5,5,
-5,5,0,0,6,5,8,6,8,6,6,6,6,0,0,8,
-8,0,0,8,8,6,0,0,0,0,0,0,0,0,6,8,
-0,0,0,0,5,5,0,5,0,0,0,0,0,0,0x49,0x89,
-0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0x1e4b,0x784b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x19,0x1b,0,0,0,0,0,0,0,6,5,0,5,5,5,
-5,5,5,0,0,0,5,5,5,0,5,5,5,5,0,0,
-0,5,5,0,5,0,5,5,0,0,0,5,5,0,0,0,
-5,5,5,0,0,0,5,5,5,5,5,5,5,5,5,5,
-5,5,0,0,0,0,8,8,6,8,8,0,0,0,8,8,
-8,0,8,8,8,6,0,0,5,0,0,0,0,0,0,8,
-0,0,0,0,0,0,0,0,5,5,6,6,0,0,0x49,0x89,
-0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,0,0,
-0x54b,0x58b,0x5cb,0x60b,0x58b,0x5cb,0x60b,0x1b,6,8,8,8,0,5,5,5,
-5,5,5,5,5,0,5,5,5,0,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,0,0,5,6,6,
-6,8,8,8,8,0,6,6,6,0,6,6,6,6,0,0,
-0,0,0,0,0,6,6,0,5,5,5,0,0,0,0,0,
-5,5,6,6,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
-0,5,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
-5,6,8,8,0,5,5,5,5,5,5,5,5,0,5,5,
-5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,5,5,5,5,5,5,5,5,5,5,0,5,5,5,
-5,5,0,0,6,5,8,6,8,8,8,8,8,0,6,8,
-8,0,8,8,6,6,0,0,0,0,0,0,0,8,8,0,
-0,0,0,0,0,0,5,0,5,5,6,6,0,0,0x49,0x89,
-0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0x1e4b,0x784b,0x34cb,0x344b,0x3ccb,0x37cb,0x35cb,
-0x3fcb,0x1b,5,5,5,5,5,5,6,6,8,8,0,5,5,5,
-5,5,5,5,5,0,5,5,5,0,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,6,6,5,8,8,8,6,6,6,
-6,0,8,8,8,0,8,8,8,6,5,0x1b,0,0,0,0,
-5,5,5,8,0xcc0b,0xca0b,0xcb4b,0xc90b,0x364b,0xc94b,0x350b,5,0,0,0,0,
-0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,8,8,
-0x17,0,0,0,0,0,0,0,0,0,0,0,0,0,8,8,
-0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,0,0,0,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,
-5,5,5,5,0,5,0,0,5,5,5,5,5,5,5,0,
-0,0,6,0,0,0,0,8,8,8,6,6,6,0,6,0,
-8,8,8,8,8,8,8,8,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,6,5,5,6,6,6,6,
-6,6,6,0,0,0,0,0x19,5,5,5,5,5,5,4,6,
-6,6,6,6,6,6,6,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0x17,0x17,0,0,0,0,0,5,5,0,5,0,0,5,
-5,0,5,0,0,5,0,0,0,0,0,0,5,5,5,5,
-0,5,5,5,5,5,5,5,0,5,5,5,0,5,0,5,
-0,0,5,5,0,5,5,5,5,6,5,5,6,6,6,6,
-6,6,0,6,6,5,0,0,5,5,5,5,5,0,4,0,
-6,6,6,6,6,6,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0,0,5,5,5,5,5,0x1b,0x1b,0x1b,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x1b,0x17,0x1b,0x1b,0x1b,
-6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0x344b,0x3c4b,0x444b,0x4c4b,0x544b,0x5c4b,0x644b,0x6c4b,0x744b,0x2c4b,0x1b,6,0x1b,6,
-0x1b,6,0x14,0x15,0x14,0x15,8,8,5,5,5,5,5,5,5,5,
-0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,0,0,0,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,8,6,6,6,6,
-6,0x17,6,6,5,5,5,5,5,6,6,6,6,6,6,6,
-6,6,6,6,0,6,6,6,6,6,6,6,6,6,6,6,
+0,0,8,8,0x17,0,0,0,0,0,0,0,0,0,0,0,
+0,0,8,8,0,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,0,0,0,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,
+5,5,5,5,5,5,5,5,0,5,0,0,5,5,5,5,
+5,5,5,0,0,0,6,0,0,0,0,8,8,8,6,6,
+6,0,6,0,8,8,8,8,8,8,8,8,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,6,5,5,
+6,6,6,6,6,6,6,0,0,0,0,0x19,5,5,5,5,
+5,5,4,6,6,6,6,6,6,6,6,0x17,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0,0,0,0,0,5,5,0,
+5,0,0,5,5,0,5,0,0,5,0,0,0,0,0,0,
+5,5,5,5,0,5,5,5,5,5,5,5,0,5,5,5,
+0,5,0,5,0,0,5,5,0,5,5,5,5,6,5,5,
+6,6,6,6,6,6,0,6,6,5,0,0,5,5,5,5,
+5,0,4,0,6,6,6,6,6,6,0,0,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,5,5,5,5,5,0x1b,0x1b,0x1b,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x1b,
+0x17,0x1b,0x1b,0x1b,6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0x344b,0x3c4b,0x444b,0x4c4b,0x544b,0x5c4b,0x644b,0x6c4b,0x744b,0x2c4b,
+0x1b,6,0x1b,6,0x1b,6,0x14,0x15,0x14,0x15,8,8,5,5,5,5,
+5,5,5,5,0,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,
+0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,8,
+6,6,6,6,6,0x17,6,6,5,5,5,5,5,6,6,6,
+6,6,6,6,6,6,6,6,0,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x17,0x17,0x17,0x17,0x17,0x1b,0x1b,0x1b,
-0x1b,0x17,0x17,0,0,0,0,0,5,5,5,5,5,5,5,5,
-5,5,5,8,8,6,6,6,6,8,6,6,6,6,6,6,
-8,6,6,8,8,6,6,5,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0x17,0x17,0x17,0x17,0x17,0x17,5,5,5,5,5,5,8,8,
-6,6,5,5,5,5,6,6,6,5,8,8,8,5,5,8,
-8,8,8,8,8,8,5,5,5,6,6,6,6,5,5,5,
-5,5,5,5,5,5,5,5,5,5,6,8,8,6,6,8,
-8,8,8,8,8,6,5,8,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,8,8,8,6,0x1b,0x1b,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,0x17,4,5,5,5,1,1,1,1,1,1,0,1,
-0,0,0,0,0,1,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,5,5,5,5,0,0,
-5,5,5,5,5,5,5,0,5,0,5,5,5,5,0,0,
-5,5,5,5,5,5,5,5,5,0,5,5,5,5,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,5,5,5,5,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,0,0,6,6,6,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
-0x17,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,
-0x16cb,0x194b,0x1bcb,0x1e4b,0x788b,0,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0,0,0,0,0,0,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,
-2,2,2,2,2,2,0,0,0x13,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0x17,0x17,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0xc,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0x14,0x15,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,0x17,0x17,0x17,0x98a,0x9ca,0xa0a,5,5,5,
-5,5,5,5,5,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,5,5,5,5,6,6,
-6,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,
-6,0x17,0x17,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,5,5,5,0,6,6,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+6,6,6,6,6,6,6,6,6,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x17,0x17,0x17,0x17,
+0x17,0x1b,0x1b,0x1b,0x1b,0x17,0x17,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,8,8,6,6,6,6,8,6,6,
+6,6,6,6,8,6,6,8,8,6,6,5,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0x17,0x17,0x17,0x17,5,5,5,5,
+5,5,8,8,6,6,5,5,5,5,6,6,6,5,8,8,
+8,5,5,8,8,8,8,8,8,8,5,5,5,6,6,6,
+6,5,5,5,5,5,5,5,5,5,5,5,5,5,6,8,
+8,6,6,8,8,8,8,8,8,6,5,8,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,8,8,8,6,0x1b,0x1b,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,0x17,4,2,2,2,1,1,1,1,
+1,1,0,1,0,0,0,0,0,1,0,0,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,0,0,5,5,5,5,
+5,5,5,0,5,0,5,5,5,5,0,0,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,5,0,0,5,5,5,5,5,5,5,0,5,0,5,5,
+5,5,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,0,5,5,5,5,0,0,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-6,6,8,6,6,6,6,6,6,6,8,8,8,8,8,8,
-8,8,6,8,8,6,6,6,6,6,6,6,6,6,6,6,
-0x17,0x17,0x17,4,0x17,0x17,0x17,0x19,5,6,0,0,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,0x54b,0x58b,0x5cb,0x60b,
-0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,6,5,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0x17,0x17,0x17,0x17,
-0x17,0x17,0x13,0x17,0x17,0x17,0x17,6,6,6,0x10,0,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,5,5,5,4,
+5,5,5,5,5,5,5,0,0,6,6,6,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,0x17,0x17,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0xa4b,
+0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0x788b,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,0,0,2,2,2,2,2,2,0,0,0x13,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
-0,0,0,0,5,5,5,5,5,6,6,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0x17,0x17,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,0,0,0,0,0,0,0,0,0,0,
-6,6,6,8,8,8,8,6,6,8,8,8,0,0,0,0,
-8,8,6,8,8,8,8,8,8,6,6,6,0,0,0,0,
-0x1b,0,0,0,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
+0xc,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0x14,0x15,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,0x17,0x17,0x17,0x98a,0x9ca,
+0xa0a,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,5,6,6,6,0,0,0,0,0,0,0,0,0,0,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-5,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
+5,5,6,6,6,0x17,0x17,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,6,6,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,5,
+5,0,6,6,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,6,6,8,6,6,6,6,6,6,6,8,8,
+8,8,8,8,8,8,6,8,8,6,6,6,6,6,6,6,
+6,6,6,6,0x17,0x17,0x17,4,0x17,0x17,0x17,0x19,5,6,0,0,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
+0x54b,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,6,5,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+0x17,0x17,0x17,0x17,0x17,0x17,0x13,0x17,0x17,0x17,0x17,6,6,6,0x10,0,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
+5,5,5,4,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0x30b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+5,0,0,0,0,0,0,0,5,5,5,5,5,6,6,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,
+0,0,0,0,6,6,6,8,8,8,8,6,6,8,8,8,
+0,0,0,0,8,8,6,8,8,8,8,8,8,6,6,6,
+0,0,0,0,0x1b,0,0,0,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,0,5,5,5,5,5,0,0,0,0,0,0,0,
+0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
+0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0x30b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,
-6,8,8,6,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,4,
-0x17,0x17,0x17,0x17,0x17,0x17,0,0,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,7,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,8,6,8,
-6,6,6,6,6,6,6,0,6,8,6,8,8,6,6,6,
-6,6,6,6,6,8,8,8,8,8,8,6,6,6,6,6,
-6,6,6,6,6,0,0,6,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0,0,0,0,0,0,0x17,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,6,6,6,6,6,6,6,6,6,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,6,6,6,6,8,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,6,8,6,6,6,6,6,8,
-6,8,8,8,8,8,6,8,8,5,5,5,5,5,5,5,
-0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,
-0x17,0x17,0x17,0x17,5,8,6,6,6,6,8,8,6,6,8,6,
-6,6,5,5,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,
-5,5,5,5,6,6,8,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,6,8,6,6,8,8,8,6,8,6,
-6,6,8,8,0,0,0,0,0,0,0,0,0x17,0x17,0x17,0x17,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,5,5,5,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,5,5,5,5,
-8,8,8,8,8,8,8,8,6,6,6,6,6,6,6,6,
-8,8,6,6,0,0,0,0x17,0x17,0x17,0x17,0x17,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,4,4,4,4,4,4,0x17,0x17,2,2,2,2,
-2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,6,6,6,0x17,
-6,6,6,6,6,6,6,6,6,6,6,6,6,8,6,6,
-6,6,6,6,6,5,5,5,5,6,5,5,5,5,8,8,
-6,5,5,8,6,6,0,0,0,0,0,0,2,2,2,2,
-2,2,2,2,2,2,2,2,4,4,4,4,4,4,4,4,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,6,6,8,8,6,0,0,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,4,0x17,0x17,0x17,0x17,0x17,0x17,0,0,6,6,6,6,
+6,6,6,6,6,6,6,6,6,6,7,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,8,6,8,6,6,6,6,6,6,6,0,6,8,6,8,
+8,6,6,6,6,6,6,6,6,8,8,8,8,8,8,6,
+6,6,6,6,6,6,6,6,6,0,0,6,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,
+0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,0x17,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,6,6,6,6,6,6,6,6,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,6,6,6,6,
+8,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,6,8,6,6,
+6,6,6,8,6,8,8,8,8,8,6,8,8,5,5,5,
+5,5,5,5,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0x17,0x17,0x17,0x17,0x17,0x17,5,8,6,6,6,6,8,8,
+6,6,8,6,6,6,5,5,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,5,5,5,5,5,5,6,6,8,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,6,8,6,6,8,8,
+8,6,8,6,6,6,8,8,0,0,0,0,0,0,0,0,
+0x17,0x17,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,
+0,5,5,5,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,5,
+5,5,5,5,8,8,8,8,8,8,8,8,6,6,6,6,
+6,6,6,6,8,8,6,6,0,0,0,0x17,0x17,0x17,0x17,0x17,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,4,4,4,4,4,4,0x17,0x17,
+2,2,2,2,2,2,2,2,2,0,0,0,0,0,0,0,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,
+6,6,6,0x17,6,6,6,6,6,6,6,6,6,6,6,6,
+6,8,6,6,6,6,6,6,6,5,5,5,5,6,5,5,
+5,5,8,8,6,5,5,8,6,6,0,0,0,0,0,0,
+2,2,2,2,2,2,2,2,2,2,2,2,4,4,4,4,
 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,4,4,4,4,4,2,2,2,2,2,
-2,2,2,2,2,2,2,2,4,2,2,2,2,2,2,2,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,2,
+2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,4,4,4,4,4,6,6,6,6,
+2,2,2,2,2,2,2,2,2,2,2,4,4,4,4,4,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,0,6,6,6,6,6,1,2,1,2,
+6,6,6,6,6,6,6,6,6,6,0,6,6,6,6,6,
 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
-1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,
-2,2,2,2,1,1,1,1,1,0x1a,0x1a,0x1a,0,0,2,2,
-2,0,2,2,1,1,1,1,3,0x1a,0x1a,0,2,2,2,2,
-2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,0,0,1,1,1,1,1,1,0,0,2,2,2,2,
-2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,0,0,1,1,1,1,1,1,0,0,2,2,2,2,
-2,2,2,2,0,1,0,1,0,1,0,1,2,2,2,2,
-2,2,2,2,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,0,0,2,2,2,2,
-2,2,2,2,3,3,3,3,3,3,3,3,2,2,2,2,
-2,2,2,2,3,3,3,3,3,3,3,3,2,2,2,2,
-2,0,2,2,1,1,1,1,3,0x1a,2,0x1a,0x1a,0x1a,2,2,
-2,0,2,2,1,1,1,1,3,0x1a,0x1a,0x1a,2,2,2,2,
-0,0,2,2,1,1,1,1,0,0x1a,0x1a,0x1a,0x16,0x17,0x17,0x17,
-0x18,0x14,0x15,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x18,0x17,
-0x16,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0xc,0x10,0x10,0x10,0x10,
-0x10,0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x2cb,4,0,0,
-0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x18,0x18,0x18,0x14,0x15,4,0xc,0xc,0xc,0xc,
-0xc,0xc,0xc,0xc,0xc,0xc,0xc,0x10,0x10,0x10,0x10,0x10,0x13,0x13,0x13,0x13,
-0x13,0x13,0x17,0x17,0x1c,0x1d,0x14,0x1c,0x1c,0x1d,0x14,0x1c,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0xd,0xe,0x10,0x10,0x10,0x10,0x10,0xc,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0x17,0x1c,0x1d,0x17,0x17,0x17,0x17,0x16,0x2cb,0x30b,0x34b,0x38b,
-0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x18,0x18,0x18,0x14,0x15,0,4,4,4,4,
-4,4,4,4,4,4,4,4,4,0,0,0,0x19,0x19,0x19,0x19,
+1,2,1,2,1,2,2,2,2,2,2,2,2,2,1,2,
+2,2,2,2,2,2,2,2,1,1,1,1,1,0x1a,0x1a,0x1a,
+0,0,2,2,2,0,2,2,1,1,1,1,3,0x1a,0x1a,0,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,
+2,2,2,2,2,2,0,0,1,1,1,1,1,1,0,0,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,
+2,2,2,2,2,2,0,0,1,1,1,1,1,1,0,0,
+2,2,2,2,2,2,2,2,0,1,0,1,0,1,0,1,
+2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,
+2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,
+2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,
+2,2,2,2,2,0,2,2,1,1,1,1,3,0x1a,2,0x1a,
+0x1a,0x1a,2,2,2,0,2,2,1,1,1,1,3,0x1a,0x1a,0x1a,
+2,2,2,2,0,0,2,2,1,1,1,1,0,0x1a,0x1a,0x1a,
+0x16,0x17,0x17,0x17,0x18,0x14,0x15,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x18,0x17,0x16,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0xc,
+0x10,0x10,0x10,0x10,0x10,0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
+0x2cb,4,0,0,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x18,0x18,0x18,0x14,0x15,4,
+0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0x10,0x10,0x10,0x10,0x10,
+0x13,0x13,0x13,0x13,0x13,0x13,0x17,0x17,0x1c,0x1d,0x14,0x1c,0x1c,0x1d,0x14,0x1c,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0xd,0xe,0x10,0x10,0x10,0x10,0x10,0xc,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x1c,0x1d,0x17,0x17,0x17,0x17,0x16,
+0x2cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x18,0x18,0x18,0x14,0x15,0,
+4,4,4,4,4,4,4,4,4,4,4,4,4,0,0,0,
 0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,
-0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,
-6,6,6,6,6,6,6,6,6,7,7,7,7,6,7,7,
-7,6,6,6,6,6,6,6,6,6,6,6,6,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,
-1,0x1b,1,0x1b,1,0x1b,1,1,1,1,0x1b,2,1,1,1,1,
-2,5,5,5,5,2,0x1b,0x1b,2,2,1,1,0x18,0x18,0x18,0x18,
-0x18,1,2,2,2,2,0x1b,0x18,0x1b,0x1b,2,0x1b,0x358b,0x360b,0x364b,0x348b,
-0x388b,0x350b,0x390b,0x3d0b,0x410b,0x354b,0x454b,0x35cb,0x3dcb,0x45cb,0x4dcb,0x58b,0x1b,0x1b,1,0x1b,
-0x1b,0x1b,0x1b,1,0x1b,0x1b,2,1,1,1,2,2,1,1,1,2,
-0x1b,1,0x1b,0x1b,0x18,1,1,1,1,1,0x1b,0x1b,0x58a,0x5ca,0x60a,0x64a,
-0x68a,0x6ca,0x70a,0x74a,0x78a,0x7ca,0x80a,0x84a,0x11ca,0x1e4a,0x980a,0x784a,0x58a,0x5ca,0x60a,0x64a,
-0x68a,0x6ca,0x70a,0x74a,0x78a,0x7ca,0x80a,0x84a,0x11ca,0x1e4a,0x980a,0x784a,0x784a,0x984a,0x788a,1,
-2,0x6ca,0x11ca,0x988a,0x78ca,0x54b,0x1b,0x1b,0,0,0,0,0x18,0x18,0x18,0x18,
-0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x18,0x1b,0x1b,0x18,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x1b,0x1b,0x18,0x1b,
-0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,
+0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,0x19,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,
+7,6,7,7,7,6,6,6,6,6,6,6,6,6,6,6,
+6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x1b,0x1b,0x1b,0x1b,1,0x1b,1,0x1b,1,0x1b,1,1,1,1,0x1b,2,
+1,1,1,1,2,5,5,5,5,2,0x1b,0x1b,2,2,1,1,
+0x18,0x18,0x18,0x18,0x18,1,2,2,2,2,0x1b,0x18,0x1b,0x1b,2,0x1b,
+0x358b,0x360b,0x364b,0x348b,0x388b,0x350b,0x390b,0x3d0b,0x410b,0x354b,0x454b,0x35cb,0x3dcb,0x45cb,0x4dcb,0x58b,
+0x1b,0x1b,1,0x1b,0x1b,0x1b,0x1b,1,0x1b,0x1b,2,1,1,1,2,2,
+1,1,1,2,0x1b,1,0x1b,0x1b,0x18,1,1,1,1,1,0x1b,0x1b,
+0x58a,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x7ca,0x80a,0x84a,0x11ca,0x1e4a,0x980a,0x784a,
+0x58a,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x7ca,0x80a,0x84a,0x11ca,0x1e4a,0x980a,0x784a,
+0x784a,0x984a,0x788a,1,2,0x6ca,0x11ca,0x988a,0x78ca,0x54b,0x1b,0x1b,0,0,0,0,
+0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x18,
+0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,
+0x1b,0x1b,0x18,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x14,0x15,0x14,0x15,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x14,0x15,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x14,0x15,0x14,0x15,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x14,0x15,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x2cb,0x80b,
-0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,
-0x4cb,0x50b,0x7cb,0x2cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x80b,0x84b,
-0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,
-0x50b,0x7cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x2cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,0x30b,0x34b,0x38b,
+0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x2cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,
+0x50b,0x7cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,0x30b,0x34b,0x38b,0x3cb,
+0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0xa4b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x30b,0x34b,
-0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,
-0x50b,0x7cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x14,0x15,0x14,0x15,
-0x14,0x15,0x14,0x15,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,
-0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x14,0x15,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x18,0x18,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,
+0x14,0x15,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x30b,0x34b,0x38b,0x3cb,
+0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x18,
-0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,
+0x18,0x14,0x15,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,
+0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x14,0x15,0x14,
+0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,
+0x15,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x14,0x15,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x14,0x15,0x18,0x18,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,
+0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,0,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,0,2,2,2,2,
@@ -749,8 +750,8 @@ static const uint16_t propsTrie_index[21148]={
 0x1c,0x1d,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x13,0x17,0x17,0x13,0x17,
 0x1c,0x1d,0x17,0x17,0x1c,0x1d,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x17,0x17,
 0x17,0x17,0x17,4,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x13,0x13,
-0x17,0x17,0x17,0x17,0x13,0x17,0x14,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x17,0x17,0x17,0x17,0x13,0x17,0x14,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
@@ -768,9 +769,11 @@ static const uint16_t propsTrie_index[21148]={
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,0x17,4,4,4,5,0,0,0,0,0,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,0,0,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
-0x1b,0x1b,0x58b,0x5cb,0x60b,0x64b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0,0x1b,0x1b,0x58b,0x5cb,
+0x60b,0x64b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,
 0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,0x58b,0x5cb,0x60b,0x64b,
 0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
@@ -834,6 +837,8 @@ static const uint16_t propsTrie_index[21148]={
 5,5,5,5,5,5,5,5,0x6c5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,0x545,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
 5,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,4,5,5,5,5,5,5,
@@ -858,7 +863,7 @@ static const uint16_t propsTrie_index[21148]={
 2,2,2,2,2,1,2,1,2,1,1,2,1,2,1,2,
 1,2,1,2,4,0x1a,0x1a,1,2,1,2,5,1,2,1,2,
 2,2,1,2,1,2,1,2,1,2,1,2,1,2,1,1,
-1,1,1,0,1,1,1,1,1,2,1,2,0,0,0,0,
+1,1,1,2,1,1,1,1,1,2,1,2,1,2,0,0,
 0,0,0,0,5,5,6,5,5,5,6,5,5,5,5,6,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,8,8,6,6,8,0x1b,0x1b,0x1b,0x1b,
@@ -871,13 +876,11 @@ static const uint16_t propsTrie_index[21148]={
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,8,8,8,8,8,8,8,8,8,8,8,8,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,5,5,5,5,5,5,0x17,0x17,0x17,5,0x17,5,0,0,
+6,6,5,5,5,5,5,5,0x17,0x17,0x17,5,0x17,5,5,6,
 5,5,5,5,5,5,6,6,6,6,6,6,6,6,0x17,0x17,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,6,6,6,6,6,6,6,6,6,6,6,8,8,
-0,0,0,0,0,0,0,0,0,0,0,0x17,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,0,0,8,0x17,0x17,0x17,
+0,0,0,0,0,0,0,0,0,0,0,0x17,8,0x17,0x17,0x17,
 0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,4,0x49,0x89,0xc9,0x109,
 0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0x17,0x17,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,
@@ -906,153 +909,162 @@ static const uint16_t propsTrie_index[21148]={
 8,6,8,8,6,8,8,0x17,8,6,0,0,0x49,0x89,0xc9,0x109,
 0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,5,5,5,5,
 0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
-0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,0,0,0,0,5,5,5,5,
+5,5,5,0,0,0,0,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,0x12,0x12,0x12,0x12,
 0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
+0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x11,0x11,0x11,0x11,
 0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,
-0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,5,5,5,5,5,5,5,5,
-5,5,5,0x605,5,5,5,5,5,5,5,0x7c5,5,5,5,5,
-0x5c5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,0x6c5,5,0x6c5,5,5,5,5,5,5,5,5,
+0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,5,5,5,5,
+5,5,5,5,5,5,5,0x605,5,5,5,5,5,5,5,0x7c5,
+5,5,5,5,0x5c5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,0x6c5,5,0x6c5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,0x7c5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0x18,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,
+5,0,5,0,5,5,0,5,5,0,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,2,2,2,2,2,2,2,0,0,0,0,0,
+0,0,0,0,0,0,0,2,2,2,2,2,0,0,0,0,
+0,5,6,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,
+0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,0x15,0x14,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,0,0,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,0x19,0x1b,0,0,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x14,0x15,0x17,0,0,0,0,0,0,
+6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+0x17,0x13,0x13,0x16,0x16,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,
+0x15,0x17,0x17,0x14,0x15,0x17,0x17,0x17,0x17,0x16,0x16,0x16,0x17,0x17,0x17,0,
+0x17,0x17,0x17,0x17,0x13,0x14,0x15,0x14,0x15,0x14,0x15,0x17,0x17,0x17,0x18,0x13,
+0x18,0x18,0x18,0,0x17,0x19,0x17,0x17,0,0,0,0,5,5,5,5,
+5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,0x7c5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0x18,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,5,5,5,5,5,0,5,0,
-5,5,0,5,5,0,5,5,5,5,5,5,5,5,5,5,
+5,0,0,0x10,0,0,5,5,5,5,5,5,0,0,5,5,
+5,5,5,5,0,0,5,5,5,5,5,5,0,0,5,5,
+5,0,0,0,0x19,0x19,0x18,0x1a,0x1b,0x19,0x19,0,0x1b,0x18,0x18,0x18,
+0x18,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0x10,0x10,0x10,
+0x1b,0x1b,0,0,0,0x17,0x17,0x17,0x19,0x17,0x17,0x17,0x14,0x15,0x17,0x18,
+0x17,0x13,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,
+0x18,0x18,0x18,0x17,0x1a,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0x14,
+0x18,0x15,0x18,0x14,0x15,0x17,0x14,0x15,0x17,0x17,5,5,5,5,5,5,
+5,5,5,5,4,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,4,4,5,5,5,5,5,5,5,5,
+5,5,5,5,0,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
+5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,0,0xb00b,0xb80b,0x784b,0x804b,0x884b,0x904b,0x984b,0xa04b,0xa84b,0xb04b,0xb84b,0x788b,
+0x808b,0x888b,0x908b,0x988b,0xa08b,0xa88b,0xb08b,0xb88b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x17,0x17,0x17,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x68b,
+0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0x800b,0x880b,
+0x900b,0x980b,0xa00b,0xa80b,0x7ca,0x7ca,0x7ca,0x7ca,0x7ca,0xcca,0x11ca,0x11ca,0x11ca,0x11ca,0x1e4a,0x880a,
+0x980a,0x980a,0x980a,0x980a,0x980a,0x784a,0x984a,0x68a,0x11ca,0x344b,0x344b,0x388b,0x3ccb,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x54b,0x34cb,0x1b,0x1b,0x1b,0,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
+0x34ca,0x344a,0x58a,0x68a,0x11ca,0x980a,0x984a,0x988a,0x68a,0x7ca,0x11ca,0x1e4a,0x980a,0x784a,0x984a,0x68a,
+0x7ca,0x11ca,0x1e4a,0x980a,0x784a,0x788a,0x988a,0x7ca,0x58a,0x58a,0x58a,0x5ca,0x5ca,0x5ca,0x5ca,0x68a,
+0x1b,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,0,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,
-0,0,0,2,2,2,2,2,0,0,0,0,0,5,6,5,
+5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+6,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,
+0x16cb,0x194b,0x1bcb,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0,0,0,0,
+0x58b,0x68b,0x7cb,0x11cb,0,0,0,0,0,0,0,0,0,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,
-0x1a,0x1a,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,0x1bca,5,5,5,5,5,5,5,5,0xb80a,0,0,0,0,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,0x15,0x14,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,0,0,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,0x19,0x1b,0,0,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x14,0x15,0x17,0,0,0,0,0,0,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,0x17,0x13,0x13,0x16,
-0x16,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x14,0x15,0x17,0x17,0x14,
-0x15,0x17,0x17,0x17,0x17,0x16,0x16,0x16,0x17,0x17,0x17,0,0x17,0x17,0x17,0x17,
-0x13,0x14,0x15,0x14,0x15,0x14,0x15,0x17,0x17,0x17,0x18,0x13,0x18,0x18,0x18,0,
-0x17,0x19,0x17,0x17,0,0,0,0,5,5,5,5,5,0,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,0x10,
-0,0,5,5,5,5,5,5,0,0,5,5,5,5,5,5,
-0,0,5,5,5,5,5,5,0,0,5,5,5,0,0,0,
-0x19,0x19,0x18,0x1a,0x1b,0x19,0x19,0,0x1b,0x18,0x18,0x18,0x18,0x1b,0x1b,0,
-0,0,0,0,0,0,0,0,0,0x10,0x10,0x10,0x1b,0x1b,0,0,
-0,0x17,0x17,0x17,0x19,0x17,0x17,0x17,0x14,0x15,0x17,0x18,0x17,0x13,0x17,0x17,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x17,0x17,0x18,0x18,0x18,0x17,
-0x1a,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,0x14,0x18,0x15,0x18,0x14,
-0x15,0x17,0x14,0x15,0x17,0x17,5,5,5,5,5,5,5,5,5,5,
-4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,4,4,5,5,5,5,5,5,5,5,5,5,5,5,
-0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,0,5,5,0,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-0xb00b,0xb80b,0x784b,0x804b,0x884b,0x904b,0x984b,0xa04b,0xa84b,0xb04b,0xb84b,0x788b,0x808b,0x888b,0x908b,0x988b,
-0xa08b,0xa88b,0xb08b,0xb88b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x17,0x17,0x17,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,
-0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,
-0x7ca,0x7ca,0x7ca,0x7ca,0x7ca,0xcca,0x11ca,0x11ca,0x11ca,0x11ca,0x1e4a,0x880a,0x980a,0x980a,0x980a,0x980a,
-0x980a,0x784a,0x984a,0x68a,0x11ca,0x344b,0x344b,0x388b,0x3ccb,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x54b,0x34cb,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0x34ca,0x344a,0x58a,0x68a,
-0x11ca,0x980a,0x984a,0x988a,0x68a,0x7ca,0x11ca,0x1e4a,0x980a,0x784a,0x984a,0x68a,0x7ca,0x11ca,0x1e4a,0x980a,
-0x784a,0x788a,0x988a,0x7ca,0x58a,0x58a,0x58a,0x5ca,0x5ca,0x5ca,0x5ca,0x68a,0x1b,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,6,0x58b,0x5cb,0x60b,
-0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,
-0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0,0,0,0,0x58b,0x68b,0x7cb,0x11cb,
-0,0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0x1bca,5,5,
-5,5,5,5,5,5,0xb80a,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,6,6,6,6,6,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,0x17,5,5,5,5,
-0,0,0,0,5,5,5,5,5,5,5,5,0x17,0x58a,0x5ca,0x7ca,
-0xa4a,0x1e4a,0,0,0,0,0,0,0,0,0,0,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,5,5,5,5,
+5,5,5,5,5,5,6,6,6,6,6,0,0,0,0,0,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,0,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0x17,
+5,5,5,5,0,0,0,0,5,5,5,5,5,5,5,5,
+0x17,0x58a,0x5ca,0x7ca,0xa4a,0x1e4a,0,0,0,0,0,0,0,0,0,0,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,0,0,0,0,1,1,1,1,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-0,0,0,0,2,2,2,2,2,2,2,2,5,5,5,5,
-5,5,5,5,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
-0,0,0,0,0,0,0,0x17,0,0,0,0,0,0,0,0,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,0,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,0,0,0,0,2,2,2,2,2,2,2,2,
+5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+0,0,0,0,0,0,0,0,0,0,0,0x17,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,5,5,0,0,0,5,0,0,5,5,5,5,5,
+5,5,0,0,5,0,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0x17,
+0x58b,0x5cb,0x60b,0x7cb,0xa4b,0x1e4b,0x784b,0x788b,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0x1b,
+0x1b,0x58b,0x5cb,0x60b,0x64b,0x68b,0x7cb,0xa4b,0,0,0,0,0,0,0,0x58b,
+0x5cb,0x60b,0x64b,0x64b,0x68b,0x7cb,0xa4b,0x1e4b,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,5,
-5,0,0,0,5,0,0,5,5,5,5,5,5,5,0,0,
-5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,0x17,0x58b,0x5cb,0x60b,0x7cb,
-0xa4b,0x1e4b,0x784b,0x788b,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,0x1b,0x1b,0x58b,0x5cb,0x60b,
-0x64b,0x68b,0x7cb,0xa4b,0,0,0,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x64b,
-0x68b,0x7cb,0xa4b,0x1e4b,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,5,5,0,0,0,0,0,0x58b,
-0x68b,0x7cb,0xa4b,0x1e4b,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0x58b,0x7cb,0xa4b,0x1e4b,0x5cb,0x60b,
-0,0,0,0x17,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-0,0,0,0x17,0xa04b,0xa84b,0xb04b,0xb84b,0x788b,0x808b,0x888b,0x908b,0x988b,0xa08b,0xa88b,0xb08b,
-0xb88b,0x78cb,0x80cb,0x88cb,0x90cb,0x98cb,0xa0cb,0xa8cb,0xb0cb,0xb8cb,0x36cb,0x354b,0x34cb,0x348b,0x46cb,0x344b,
-0x4ecb,0x388b,0x3ccb,0x454b,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
-0x5ecb,0x344b,5,5,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,
-0xf4b,0x11cb,0x144b,0x16cb,0,0,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0x784b,
-0x804b,0x884b,0x904b,0x984b,0x30b,0x34b,0x38b,0x3cb,0x7cb,0xa4b,0x1e4b,0x784b,0,0,0,0,
-0,0,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,0,
-0,0,0,0,5,6,6,6,0,6,6,0,0,0,0,0,
-6,6,6,6,5,5,5,5,0,5,5,5,0,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,0,5,5,0,0,
+0,0,0,0x58b,0x68b,0x7cb,0xa4b,0x1e4b,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0x58b,0x7cb,
+0xa4b,0x1e4b,0x5cb,0x60b,0,0,0,0x17,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,0,0,0,0,0x17,0xa04b,0xa84b,0xb04b,0xb84b,0x788b,0x808b,0x888b,0x908b,
+0x988b,0xa08b,0xa88b,0xb08b,0xb88b,0x78cb,0x80cb,0x88cb,0x90cb,0x98cb,0xa0cb,0xa8cb,0xb0cb,0xb8cb,0x36cb,0x354b,
+0x34cb,0x348b,0x46cb,0x344b,0x4ecb,0x388b,0x3ccb,0x454b,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+0,0,0,0,0x5ecb,0x344b,5,5,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,
+0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0,0,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,
+0xa80b,0xb00b,0xb80b,0x784b,0x804b,0x884b,0x904b,0x984b,0x30b,0x34b,0x38b,0x3cb,0x7cb,0xa4b,0x1e4b,0x784b,
+0x344b,0,0,0,0,0,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0,0,0,0,0,0,0,5,6,6,6,0,6,6,0,
+0,0,0,0,6,6,6,6,5,5,5,5,0,5,5,5,
+0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,0,0,6,6,6,0,
+0,0,0,6,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,0,0,0,0,6,6,6,0,0,0,0,6,
+5,0x58b,0x11cb,0x17,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0x58b,0x11cb,0x17,
+5,0x58b,0x7cb,0xa4b,5,5,5,5,5,6,6,0,0,0,0,0x58b,
+0x68b,0x7cb,0xa4b,0x1e4b,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,
+0,0,0,0,5,5,5,5,5,5,5,5,0x1b,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0x58b,0x7cb,0xa4b,
-5,5,5,5,5,6,6,0,0,0,0,0x58b,0x68b,0x7cb,0xa4b,0x1e4b,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,0x1b,5,5,5,5,5,5,5,
+5,5,5,5,5,5,0,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,0,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,5,5,5,5,
+5,5,5,5,5,5,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,0x784b,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,0x784b,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
-0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,0x784b,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-0,0,0,0,0,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,
-0,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,
-0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,
-0,0,0,0,0,0,0x58b,0x68b,0x7cb,0x11cb,0x1e4b,0x784b,0x30b,0x34b,0x38b,0x3cb,
-0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0x800b,
-0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0x344b,0x34cb,0x348b,0x388b,0,0x144b,0x16cb,0x194b,0x1bcb,
+5,5,5,0,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,0x784b,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,0,0,0,0,0,0,0,0x17,0x17,0x17,0x17,0,0,0,
+0,0,0,0,0,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x7cb,0xa4b,0x1e4b,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,0,0,0,0,0,0,0,0x58b,0x68b,0x7cb,0x11cb,0x1e4b,0x784b,
+5,5,5,5,6,6,6,6,0,0,0,0,0,0,0,0,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
+0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,
+0x194b,0x1bcb,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0x344b,0x34cb,0x348b,0x388b,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,0x58b,0x5cb,0x60b,
+0x64b,0x68b,0x7cb,0xa4b,0xccb,0x1e4b,0x344b,5,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,6,6,6,6,6,6,6,6,6,6,6,0x58b,0x7cb,0xa4b,
+0x1e4b,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0x144b,0x16cb,0x194b,0x1bcb,
 0x1e4b,0x784b,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,6,8,6,8,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
@@ -1061,17 +1073,17 @@ static const uint16_t propsTrie_index[21148]={
 0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,8,8,8,6,
 6,6,6,8,8,6,6,0x17,0x17,0x10,0x17,0x17,0x17,0x17,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+0,0,0,0,0,0,0,0,0,0x10,0,0,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,
 0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,
 0,0,0,0,5,5,5,5,5,5,5,6,6,6,6,6,
 8,6,6,6,6,6,6,6,6,0,0x49,0x89,0xc9,0x109,0x149,0x189,
-0x1c9,0x209,0x249,0x289,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,
+0x1c9,0x209,0x249,0x289,0x17,0x17,0x17,0x17,5,8,8,0,0,0,0,0,
 0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,6,6,6,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,6,0x17,0x17,5,0,0,0,0,0,
-0,0,0,0,8,5,5,5,5,0x17,0x17,0x17,0x17,0x17,6,6,
+0,0,0,0,8,5,5,5,5,0x17,0x17,0x17,0x17,6,6,6,
 6,0x17,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,5,0x17,
 5,0x17,0x17,0x17,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,8,8,8,6,6,6,6,6,6,
@@ -1091,238 +1103,245 @@ static const uint16_t propsTrie_index[21148]={
 6,6,6,6,6,0,0,0,0,0,0,0,0,0,0,0,
 6,6,8,8,0,5,5,5,5,5,5,5,5,0,0,5,
 5,0,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-6,8,8,8,8,0,0,8,8,0,0,8,8,8,0,0,
-5,0,0,0,0,0,0,8,0,0,0,0,0,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,8,8,8,6,6,6,6,6,6,6,6,
-8,8,6,6,6,8,6,5,5,5,5,0x17,0x17,0x17,0x17,0x17,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0x17,0,0x17,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-8,8,8,6,6,6,6,6,6,8,6,8,8,8,8,6,
-6,8,6,6,5,5,0x17,5,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,8,
-8,8,6,6,6,6,0,0,8,8,8,8,6,6,8,6,
-6,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,5,5,5,5,6,6,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-8,8,8,6,6,6,6,6,6,6,6,8,8,6,8,6,
-6,0x17,0x17,0x17,5,0,0,0,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0,0,0,
+5,0,5,5,5,5,5,5,5,0,5,5,0,5,5,5,
+5,5,0,6,6,5,8,8,6,8,8,8,8,0,0,8,
+8,0,0,8,8,8,0,0,5,0,0,0,0,0,0,8,
+0,0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,8,8,8,
+6,6,6,6,6,6,6,6,8,8,6,6,6,8,6,5,
+5,5,5,0x17,0x17,0x17,0x17,0x17,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0,0x17,0,0x17,6,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,8,8,8,6,6,6,6,6,
+6,8,6,8,8,8,8,6,6,8,6,6,5,5,0x17,5,
+0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,8,8,8,6,6,6,6,0,0,
+8,8,8,8,6,6,8,6,6,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+5,5,5,5,6,6,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,8,8,8,6,6,6,6,6,
+6,6,6,8,8,6,8,6,6,0x17,0x17,0x17,5,0,0,0,
+0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0,0,0,0,0,0,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,
+0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,6,8,6,8,8,6,6,6,6,6,6,8,6,
+0,0,0,0,0,0,0,0,8,8,6,6,6,6,8,6,
+6,6,6,6,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0x7cb,0xa4b,0x17,0x17,0x17,0x1b,5,5,5,5,5,5,5,5,
+5,5,5,5,8,8,8,6,6,6,6,6,6,6,6,6,
+8,6,6,0x17,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0,0,0,0,0,
+0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,
+6,8,5,6,6,6,6,0x17,0x17,0x17,0x17,0x17,0x17,0x17,0x17,6,
+0,0,0,0,0,0,0,0,5,6,6,6,6,6,6,8,
+8,6,6,6,5,5,5,5,5,6,6,6,6,6,6,6,
+6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,0x17,0x17,0x17,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,5,5,5,5,0,0,5,5,
+5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,8,
+6,6,0x17,0x17,0x17,5,0x17,0x17,5,0x17,0x17,0x17,0x17,0x17,0,0,
+0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,
+0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0,0,0,0x17,0x17,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,8,6,6,6,6,6,6,6,0,6,6,6,6,
+6,6,8,6,6,6,6,6,6,6,6,6,0,8,6,6,
+6,6,6,6,6,8,6,6,8,6,6,0,0,0,0,0,
+0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,0,0,6,6,6,6,6,6,6,6,6,6,
+6,6,6,6,6,6,5,6,0,0,0,0,0,0,0,0,
 0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0,0,
+5,5,5,5,5,5,5,0,5,5,0,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,6,6,6,6,6,6,0,0,0,6,0,6,6,0,6,
+5,5,5,5,5,5,5,5,5,5,8,8,8,8,8,0,
+6,6,0,8,8,6,8,6,5,0,0,0,0,0,0,0,
+5,5,5,5,5,5,0,5,5,0,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,6,6,8,8,0x17,0x17,0,0,0,0,0,0,0,
+0x34ca,0x354a,0x34ca,0x34ca,0x344a,0x348a,0x388a,0xf4a,0x11ca,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0,
+0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,0,0,
+0x5ca,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x64a,
+0x68a,0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,
+0x60a,0x64a,0x68a,0x5ca,0x60a,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,0x60a,0x60a,
+0x64a,0x68a,0xc08a,0xc18a,0x58a,0x5ca,0x60a,0x60a,0x64a,0x68a,0x60a,0x60a,0x64a,0x64a,0x64a,0x64a,
+0x6ca,0x70a,0x70a,0x70a,0x74a,0x74a,0x78a,0x78a,0x78a,0x78a,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x58a,
+0x5ca,0x60a,0x64a,0x64a,0x68a,0x68a,0x5ca,0x60a,0x58a,0x5ca,0x348a,0x388a,0x454a,0x348a,0x388a,0x35ca,
+5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,5,5,5,6,8,6,8,8,
-6,6,6,6,6,6,8,6,0,0,0,0,0,0,0,0,
-8,8,6,6,6,6,8,6,6,6,6,6,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0xa4b,0x17,0x17,0x17,0x1b,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,0,0,0,6,6,6,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,
-0x16cb,0x194b,0x1bcb,0,0,0,0,0,0,0,0,0,0,0,0,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,6,6,6,6,6,6,8,5,6,6,6,6,0x17,
-0x17,0x17,0x17,0x17,0x17,0x17,0x17,6,0,0,0,0,0,0,0,0,
-5,6,6,6,6,6,6,8,8,6,6,6,5,5,5,5,
-5,6,6,6,6,6,6,8,8,6,6,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-5,5,5,5,0,0,5,5,5,5,6,6,6,6,6,6,
-6,6,6,6,6,6,6,8,6,6,0x17,0x17,0x17,0,0x17,0x17,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
-5,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,
-0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x1e4b,0,0,0,
-0x17,0x17,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,8,6,6,6,6,
-6,6,6,0,6,6,6,6,6,6,8,6,6,6,6,6,
-6,6,6,6,0,8,6,6,6,6,6,6,6,8,6,6,
-8,6,6,0,0,0,0,0,0,0,0,0,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,0,0,6,6,
-6,6,6,6,6,6,6,6,6,6,6,6,6,6,5,6,
 0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0,0,0,0,0,0,5,5,5,5,5,5,5,0,
-5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,0,
-0,0,6,0,6,6,0,6,0x34ca,0x354a,0x34ca,0x34ca,0x344a,0x348a,0x388a,0xf4a,
-0x11ca,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0,0x17,0x17,0x17,0x17,0x17,0,0,0,
-0,0,0,0,0,0,0,0,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,
-0x60a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,0x60a,
-0x64a,0x68a,0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,0x60a,0x64a,0x68a,0x5ca,0x60a,0x60a,0x64a,0x68a,
-0x6ca,0x70a,0x74a,0x78a,0x58a,0x5ca,0x60a,0x60a,0x64a,0x68a,0xc08a,0xc18a,0x58a,0x5ca,0x60a,0x60a,
-0x64a,0x68a,0x60a,0x60a,0x64a,0x64a,0x64a,0x64a,0x6ca,0x70a,0x70a,0x70a,0x74a,0x74a,0x78a,0x78a,
-0x78a,0x78a,0x5ca,0x60a,0x64a,0x68a,0x6ca,0x58a,0x5ca,0x60a,0x64a,0x64a,0x68a,0x68a,0x5ca,0x60a,
-0x58a,0x5ca,0x348a,0x388a,0x454a,0x348a,0x388a,0x35ca,5,5,5,5,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x249,0x289,0,0,0,0,0x17,0x17,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0x17,0x17,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
-6,6,6,6,6,0x17,0,0,0,0,0,0,0,0,0,0,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,5,0,0,6,6,6,6,6,0x17,0,0,
+0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,0x17,
+0x17,0x17,0x17,0x17,0x1b,0x1b,0x1b,0x1b,4,4,4,4,0x17,0x1b,0,0,
+0,0,0,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0,0x7cb,0x1e4b,0x788b,0x790b,0x798b,0x7a0b,0x7a8b,0,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-6,6,6,6,6,6,6,0x17,0x17,0x17,0x17,0x17,0x1b,0x1b,0x1b,0x1b,
-4,4,4,4,0x17,0x1b,0,0,0,0,0,0,0,0,0,0,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0x7cb,0x1e4b,0x788b,0x790b,0x798b,
-0x7a0b,0x7a8b,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0,0,0,0,0,5,5,5,
-5,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,
-5,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+0,0,0,0,0,5,5,5,0x54b,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,
+0x74b,0x78b,0x7cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,0x58b,0x5cb,0x60b,0x17,
+0x17,0x17,0x17,0,0,0,0,0,5,5,5,5,5,0,0,0,
+0,0,0,0,0,0,0,0,5,8,8,8,8,8,8,8,
 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-8,8,8,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,6,6,6,6,4,4,4,4,4,4,4,4,4,
-4,4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,
+8,8,8,8,8,8,8,8,8,8,8,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,4,
+4,4,4,4,4,4,4,4,4,4,4,4,4,4,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0,0,0,0,0,0,0,0,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,0,
-0,0,0,0,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
-5,5,0,0,0x1b,6,6,0x17,0x10,0x10,0x10,0x10,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0,
+0,0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,0,0,0,0,0,5,5,5,5,
+5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
+5,5,5,5,5,5,5,5,5,5,0,0,0x1b,6,6,0x17,
+0x10,0x10,0x10,0x10,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,
-0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,8,8,6,6,6,0x1b,0x1b,
-0x1b,8,8,8,8,8,8,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,6,
-6,6,6,6,6,6,6,0x1b,0x1b,6,6,6,6,6,6,6,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,6,6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x1b,0x1b,6,6,6,0x1b,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,
-0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0x249,0x289,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,
-0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x49,0x89,0xc9,0x109,0x149,0x189,
-0x1c9,0x209,0x249,0x289,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,
+0x1b,8,8,6,6,6,0x1b,0x1b,0x1b,8,8,8,8,8,8,0x10,
+0x10,0x10,0x10,0x10,0x10,0x10,0x10,6,6,6,6,6,6,6,6,0x1b,
+0x1b,6,6,6,6,6,6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,6,
+6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x1b,0x1b,6,6,
+6,0x1b,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0x54b,0x58b,0x5cb,0x60b,
+0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0x80b,0x84b,0x88b,0x8cb,0x90b,0x94b,0x98b,0x9cb,0xa0b,
+0,0,0,0,0,0,0,0,0,0,0,0,0x58b,0x5cb,0x60b,0x64b,
+0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,0x16cb,0x194b,0x1bcb,0x58b,0x5cb,
+0x60b,0x64b,0x68b,0x58b,0x68b,0,0,0,0,0,0,0,0x249,0x289,0x49,0x89,
+0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
+0x249,0x289,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,
+2,0,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+1,0,1,1,0,0,1,0,0,1,1,0,0,1,1,1,
+1,0,1,1,1,1,1,1,1,1,2,2,2,2,0,2,
+0,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,
 2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,2,2,2,2,2,2,2,0,2,2,2,2,2,2,
+1,1,1,1,2,2,2,2,1,1,0,1,1,1,1,0,
+0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
+1,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,1,1,0,1,
+1,1,1,0,1,1,1,1,1,0,1,0,0,0,1,1,
+1,1,1,1,1,0,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,
+1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,1,0,1,1,0,0,1,0,
-0,1,1,0,0,1,1,1,1,0,1,1,1,1,1,1,
-1,1,2,2,2,2,0,2,0,2,2,2,2,2,2,2,
-0,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
-1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,
-1,0,1,1,1,1,1,1,1,0,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,1,1,0,1,1,1,1,0,1,1,1,1,
-1,0,1,0,0,0,1,1,1,1,1,1,1,0,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
+2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,2,2,2,2,2,2,0,0,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,
-2,2,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,0x18,2,2,
+1,1,1,1,1,0x18,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0x18,
+2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0x18,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,0x18,2,2,2,2,2,2,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,0x18,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,0x18,2,2,
-2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,2,2,2,0x18,2,2,2,2,2,2,1,2,
-0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0x49,0x89,0xc9,0x109,
-0x149,0x189,0x1c9,0x209,0,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,6,6,6,6,6,6,6,0x1b,0x1b,0x1b,0x1b,6,
-6,6,6,6,6,6,6,6,6,6,6,6,6,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-6,0x1b,0x1b,0x17,0x17,0x17,0x17,0x17,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,6,6,6,6,6,6,6,6,0,
+2,2,2,2,2,0x18,2,2,2,2,2,2,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,0x18,
+2,2,2,2,2,2,1,2,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,
+0x1c9,0x209,0x249,0x289,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0,6,6,6,
+6,6,6,6,6,6,6,6,6,6,6,6,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,0,0,6,6,6,6,6,6,6,0,6,6,0,6,6,
-6,6,6,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,5,5,5,5,5,0,0,0x58b,
-0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,6,6,6,6,6,6,6,0,
-0,0,0,0,0,0,0,0,2,2,2,2,6,6,6,6,
-6,6,6,0,0,0,0,0,0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,
-0x249,0x289,0,0,0,0,0x17,0x17,1,1,2,2,2,2,2,2,
+6,6,6,0x1b,0x1b,0x1b,0x1b,6,6,6,6,6,6,6,6,6,
+6,6,6,6,6,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,6,0x1b,0x1b,0x17,0x17,0x17,0x17,0x17,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
+6,6,6,6,6,6,6,0,6,6,6,6,6,6,6,6,
+6,6,6,6,6,6,6,6,6,0,0,6,6,6,6,6,
+6,6,0,6,6,0,6,6,6,6,6,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,5,0,0,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,
+6,6,6,6,6,6,6,0,0,0,0,0,0,0,0,0,
+2,2,2,2,6,6,6,6,6,6,6,0,0,0,0,0,
+0x49,0x89,0xc9,0x109,0x149,0x189,0x1c9,0x209,0x249,0x289,0,0,0,0,0x17,0x17,
+1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x18,0x18,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,5,5,5,5,0,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0,5,5,0,5,0,0,5,
-0,5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,
-0,5,0,5,0,0,0,0,0,0,5,0,0,0,0,5,
-0,5,0,5,0,5,5,5,0,5,5,0,5,0,0,5,
-0,5,0,5,0,5,0,5,0,5,5,0,5,0,0,5,
-5,5,5,0,5,5,5,5,5,5,5,0,5,5,5,5,
-0,5,5,5,5,0,5,0,5,5,5,5,5,5,5,5,
-5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,0,0,0,0,0,5,5,5,0,5,5,5,
-5,5,0,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x2cb,0x2cb,0x30b,0x34b,
-0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x54b,0x54b,0,0,0,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x7cb,0xa4b,0xccb,0xf4b,0x11cb,0x144b,
+0x78cb,0x794b,0x814b,0x58b,0x5cb,0x60b,0x64b,0x68b,0x6cb,0x70b,0x74b,0x78b,0x1b,0x34cb,0x344b,0x3ccb,
+0x19,0x58b,0x5cb,0x788b,0x78cb,0,0,0,0,0,0,0,0,0,0,0,
+0x16cb,0x194b,0x1bcb,0x1e4b,0x800b,0x880b,0x900b,0x980b,0xa00b,0xa80b,0xb00b,0xb80b,0x784b,0x804b,0x884b,0x904b,
+0x984b,0xa04b,0xa84b,0xb04b,0xb84b,0x788b,0x808b,0x888b,0x908b,0x988b,0xa08b,0xa88b,0xb08b,0xb88b,0x78cb,0x80cb,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x18,0x18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+5,5,5,5,0,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+0,5,5,0,5,0,0,5,0,5,5,5,5,5,5,5,
+5,5,5,0,5,5,5,5,0,5,0,5,0,0,0,0,
+0,0,5,0,0,0,0,5,0,5,0,5,0,5,5,5,
+0,5,5,0,5,0,0,5,0,5,0,5,0,5,0,5,
+0,5,5,0,5,0,0,5,5,5,5,0,5,5,5,5,
+5,5,5,0,5,5,5,5,0,5,5,5,5,0,5,0,
+5,5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
+0,5,5,5,0,5,5,5,5,5,0,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,0,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x2cb,0x2cb,0x30b,0x34b,0x38b,0x3cb,0x40b,0x44b,0x48b,0x4cb,0x50b,0x54b,
+0x54b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,
-0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,
+0,0,0,0,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1a,0x1a,0x1a,0x1a,0x1a,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1a,
+0x1a,0x1a,0x1a,0x1a,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
 0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0,0,0,0,0,0,0,0,0x1b,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,5,0x705,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0x645,5,5,5,5,5,5,5,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0x1b,0x1b,0x1b,0x1b,0,0,0,0x1b,0,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0,0,
+0,0,0,0,5,0x705,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,0x645,5,5,5,5,5,5,5,5,5,
+5,5,5,5,0x645,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,0x685,5,5,5,5,5,5,5,5,5,5,
+5,5,0x645,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0xcc5,5,5,5,5,5,5,5,5,
-0xf45,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-0xf45,5,5,5,5,5,5,5,5,5,5,5,5,5,0x6c5,5,
+5,0x685,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,0x605,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,0xcc5,5,5,5,5,5,5,5,5,0xf45,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,0xf45,5,5,5,
+5,5,5,5,5,5,5,5,5,5,0x6c5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,0x605,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0x605,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,0x605,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,0x605,5,5,5,5,5,5,5,5,
-5,5,5,5,5,0x645,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,5,5,5,5,5,0,0,0,
-0,0,0,0,0,0,0,0,5,5,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
+5,5,5,5,0x605,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,0x605,5,5,5,5,5,5,5,5,5,5,5,5,
+5,0x645,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 5,5,5,5,5,5,5,5,5,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,5,5,5,5,5,5,5,5,
@@ -1340,1867 +1359,1915 @@ static const uint16_t propsTrie_index[21148]={
 
 static const UTrie2 propsTrie={
     propsTrie_index,
-    propsTrie_index+4464,
+    propsTrie_index+4468,
     NULL,
-    4464,
-    16684,
+    4468,
+    16984,
     0xa40,
-    0x11f0,
+    0x11f4,
     0x0,
     0x0,
     0x110000,
-    0x5298,
+    0x53c8,
     NULL, 0, FALSE, FALSE, 0, NULL
 };
 
-static const uint16_t propsVectorsTrie_index[29236]={
-0x4c4,0x4cc,0x4d4,0x4dc,0x4f4,0x4fc,0x504,0x50c,0x514,0x51c,0x524,0x52c,0x534,0x53c,0x544,0x54c,
-0x553,0x55b,0x563,0x56b,0x56e,0x576,0x57e,0x586,0x58e,0x596,0x59e,0x5a6,0x5ae,0x5b6,0x5be,0x5c6,
-0x5ce,0x5d6,0x5dd,0x5e5,0x5ed,0x5f5,0x5fd,0x605,0x60d,0x615,0x61a,0x622,0x629,0x631,0x639,0x641,
-0x649,0x651,0x659,0x661,0x668,0x670,0x678,0x680,0x688,0x690,0x698,0x6a0,0x6a8,0x6b0,0x6b8,0x6c0,
-0x193e,0xd41,0xe2e,0x6c8,0x4e4,0xe95,0xe9d,0x1ad4,0x120d,0x1225,0x1215,0x121d,0x781,0x787,0x78f,0x797,
-0x79f,0x7a5,0x7ad,0x7b5,0x7bd,0x7c3,0x7cb,0x7d3,0x7db,0x7e1,0x7e9,0x7f1,0x7f9,0x801,0x809,0x810,
-0x818,0x81e,0x826,0x82e,0x836,0x83c,0x844,0x84c,0x854,0x122d,0x85c,0x864,0x86c,0x873,0x87b,0x883,
-0x88b,0x88f,0x897,0x89e,0x8a6,0x8ae,0x8b6,0x8be,0x153d,0x1545,0x8c6,0x8ce,0x8d6,0x8de,0x8e6,0x8ed,
-0x15a3,0x1593,0x159b,0x1879,0x1881,0x123d,0x8f5,0x1235,0x1487,0x1487,0x1489,0x1251,0x1252,0x1245,0x1247,0x1249,
-0x15ab,0x15ad,0x8fd,0x15ad,0x905,0x90a,0x912,0x15b2,0x918,0x15ad,0x91e,0x926,0xc18,0x15ba,0x15ba,0x92e,
-0x15ca,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,0x15cb,
-0x15cb,0x15cb,0x15cb,0x15c2,0x936,0x15d3,0x15d3,0x93e,0xb25,0xb2d,0xb35,0xb3d,0x15e3,0x15db,0x946,0x94e,
-0x956,0x15ed,0x15f5,0x95e,0x15eb,0x966,0x1946,0xd49,0xb45,0xb4d,0xb55,0xb5a,0x17e7,0xc4b,0xc52,0x174f,
-0xbe8,0x194e,0xd51,0xd59,0xd61,0xd69,0xf4d,0xf4d,0x183f,0x1844,0xc85,0xc8d,0x18b5,0x18bd,0x19ef,0xe36,
-0x18c5,0xcd5,0xcdd,0x18cd,0x6d0,0x4e4,0xf2d,0xd71,0x176f,0x1757,0x1767,0x175f,0x17ff,0x17f7,0x17bf,0xbf8,
-0x125a,0x125a,0x125a,0x125a,0x125d,0x125a,0x125a,0x1265,0x96e,0x126d,0x972,0x97a,0x126d,0x982,0x98a,0x992,
-0x127d,0x1275,0x1285,0x99a,0x9a2,0x128d,0x9aa,0x9b2,0x1295,0x129d,0x12a5,0x12ad,0x9ba,0x12b5,0x12bc,0x12c4,
-0x12cc,0x12d4,0x12dc,0x12e4,0x12ec,0x12f3,0x12fb,0x1303,0x130b,0x1313,0x1316,0x1318,0x15fd,0x16e2,0x16e8,0x182f,
-0x1320,0x9c2,0x9ca,0x143a,0x143f,0x1442,0x144a,0x1328,0x1452,0x1452,0x1338,0x1330,0x1340,0x1348,0x1350,0x1358,
-0x1360,0x1368,0x1370,0x1378,0x16f0,0x1747,0x1889,0x19cf,0x1388,0x138f,0x1397,0x139f,0x1380,0x13a7,0x16f8,0x16ff,
-0x1605,0x1605,0x1605,0x1605,0x1605,0x1605,0x1605,0x1605,0x1707,0x170a,0x1707,0x1707,0x1712,0x1719,0x171b,0x1722,
-0x172a,0x172e,0x172e,0x1731,0x172e,0x172e,0x1737,0x172e,0x1777,0x1837,0x1891,0xb62,0xb68,0xb6e,0xb76,0xb7b,
-0x17d7,0xc28,0xc2c,0x184c,0x17c7,0x17c7,0x17c7,0xc00,0x17cf,0xc20,0x1817,0xc75,0xc08,0xc10,0xc10,0x18d5,
-0x1807,0x1899,0xc62,0xc65,0x9d2,0x160d,0x160d,0x9da,0x1615,0x1615,0x1615,0x1615,0x1615,0x1615,0x9e2,0x6d4,
-0x146f,0x1491,0x9ea,0x1499,0x9f2,0x14a1,0x14a9,0x14b1,0x9fa,0x9ff,0x14b9,0x14c0,0xa04,0xa0c,0x1827,0xbf0,
-0xa14,0x1517,0x151e,0x14c8,0x1526,0x152d,0x14d0,0xa1c,0x14e9,0x14e9,0x14eb,0x14d8,0x14e0,0x14e0,0x14e1,0x1535,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x11c2,0x177f,0x177f,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,
-0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14f3,0x14fa,0x1936,0x11ca,
-0x1625,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,
-0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,0x162b,
-0x162b,0x162b,0x162b,0x162b,0xa24,0x1633,0xa2c,0x1956,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0x18dd,0xce5,0x18f1,0x18e9,0x18f3,0x195e,0x195e,0xd79,0x17df,0x1854,0x18a9,0x18ad,0x18a1,0xc95,0xc9b,0xc9e,
-0x180f,0xc6d,0x185c,0xca6,0x18fb,0x18fe,0xced,0xd81,0x190e,0x1906,0xcf5,0xd89,0x1966,0x196a,0xd91,0xff3,
-0x1916,0xcfd,0xd05,0x1972,0x1982,0x197a,0xd99,0xef0,0xe3e,0xe46,0x1b47,0xfab,0x1bec,0x1bec,0x198a,0xda1,
-0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,
-0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,
-0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,
-0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,
-0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,
-0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,
-0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,
-0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,
-0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,
-0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,
-0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,
-0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,
-0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,
-0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,
-0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,
-0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,
-0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,
-0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,
-0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,
-0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,
-0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,
-0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0xa34,0xda9,0xdac,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,
-0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,0x155d,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,
-0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x145a,0x1502,0x1502,0x1502,0x1502,0x1502,0x1502,0x1502,0x1502,
-0x1507,0x150f,0x173f,0x11d2,0x181f,0x181f,0x11d6,0x11dd,0xa3c,0xa44,0xa4c,0x13c7,0x13ce,0x13d6,0xa54,0x13de,
-0x140f,0x140f,0x13b7,0x13bf,0x13e6,0x1406,0x1407,0x1417,0x13ee,0x13af,0xa5c,0x13f6,0xa64,0x13fe,0xa6c,0xa70,
-0xc7d,0x141f,0xa78,0xa80,0x1427,0x142d,0x1432,0xa88,0xa98,0x1477,0x147f,0x1462,0x1467,0xaa0,0xaa8,0xa90,
-0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,
-0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x154d,0x1555,0x1555,0x1555,0x1555,
-0x1390,0x1390,0x13d0,0x1410,0x1450,0x1490,0x14d0,0x1510,0x154c,0x158c,0x15b8,0x15f8,0x1638,0x1678,0x16b8,0x16f8,
-0x1738,0x1774,0x17b4,0x17f4,0x1834,0x1868,0x18a4,0x18e4,0x1924,0x1964,0x19a0,0x19e0,0x1a20,0x1a60,0x1aa0,0x1ae0,
-0xa80,0xac0,0xb00,0xb3b,0xb7b,0xa40,0xbbb,0xa40,0xe65,0xa40,0xa40,0xa40,0xa40,0xbfb,0x1290,0x1290,
-0xea5,0xee5,0xa40,0xa40,0xa40,0xa40,0xc3b,0xc5b,0xa40,0xa40,0xc9b,0xcdb,0xd1b,0xe2d,0xded,0xd5d,
-0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,
-0x11d0,0x11d0,0x11d0,0x11d0,0xf25,0x1210,0x1045,0x1085,0x1250,0x1090,0x12d0,0x12d0,0x12d0,0xf65,0xf85,0xfc5,
-0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,
-0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0xf85,0x1005,
+static const uint16_t propsVectorsTrie_index[30012]={
+0x4d5,0x4dd,0x4e5,0x4ed,0x505,0x50d,0x515,0x51d,0x525,0x52d,0x535,0x53d,0x545,0x54d,0x555,0x55d,
+0x564,0x56c,0x574,0x57c,0x57f,0x587,0x58f,0x597,0x59f,0x5a7,0x5af,0x5b7,0x5bf,0x5c7,0x5cf,0x5d7,
+0x5df,0x5e7,0x5ee,0x5f6,0x5fe,0x606,0x60e,0x616,0x61e,0x626,0x62b,0x633,0x63a,0x642,0x64a,0x652,
+0x65a,0x662,0x66a,0x672,0x679,0x681,0x689,0x691,0x699,0x6a1,0x6a9,0x6b1,0x6b9,0x6c1,0x6c9,0x6d1,
+0x19a7,0xd68,0xe47,0x6d9,0x4f5,0xeae,0xeb6,0x1b46,0x1276,0x128e,0x127e,0x1286,0x7ae,0x7b4,0x7bc,0x7c4,
+0x7cc,0x7d2,0x7da,0x7e2,0x7ea,0x7f0,0x7f8,0x800,0x808,0x80e,0x816,0x81e,0x826,0x82e,0x836,0x83d,
+0x845,0x84b,0x853,0x85b,0x863,0x869,0x871,0x879,0x881,0x1296,0x889,0x891,0x899,0x8a0,0x8a8,0x8b0,
+0x8b8,0x8bc,0x8c4,0x8cb,0x8d3,0x8db,0x8e3,0x8eb,0x15a6,0x15ae,0x8f3,0x8fb,0x903,0x90b,0x913,0x91a,
+0x160c,0x15fc,0x1604,0x18e2,0x18ea,0x12a6,0x922,0x129e,0x14f0,0x14f0,0x14f2,0x12ba,0x12bb,0x12ae,0x12b0,0x12b2,
+0x1614,0x1616,0x92a,0x1616,0x932,0x937,0x93f,0x161b,0x945,0x1616,0x94b,0x953,0xc3d,0x1623,0x1623,0x95b,
+0x1633,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,0x1634,
+0x1634,0x1634,0x1634,0x162b,0x963,0x163c,0x163c,0x96b,0xb52,0xb5a,0xb62,0xb6a,0x164c,0x1644,0x973,0x97b,
+0x983,0x1656,0x165e,0x98b,0x1654,0x993,0x19af,0xd70,0xb72,0xb7a,0xb82,0xb87,0x1850,0xc70,0xc77,0x17b8,
+0xc0d,0x19b7,0xd78,0xd80,0xd88,0xd90,0xf66,0xf66,0x18a8,0x18ad,0xcab,0xcb3,0x191e,0x1926,0x1a68,0xe4f,
+0x192e,0xcfc,0xd04,0x1936,0x112a,0x11ca,0xf46,0xd98,0x17d8,0x17c0,0x17d0,0x17c8,0x1868,0x1860,0x1828,0xc1d,
+0x12c3,0x12c3,0x12c3,0x12c3,0x12c6,0x12c3,0x12c3,0x12ce,0x99b,0x12d6,0x99f,0x9a7,0x12d6,0x9af,0x9b7,0x9bf,
+0x12e6,0x12de,0x12ee,0x9c7,0x9cf,0x12f6,0x9d7,0x9df,0x12fe,0x1306,0x130e,0x1316,0x9e7,0x131e,0x1325,0x132d,
+0x1335,0x133d,0x1345,0x134d,0x1355,0x135c,0x1364,0x136c,0x1374,0x137c,0x137f,0x1381,0x1666,0x174b,0x1751,0x1898,
+0x1389,0x9ef,0x9f7,0x14a3,0x14a8,0x14ab,0x14b3,0x1391,0x14bb,0x14bb,0x13a1,0x1399,0x13a9,0x13b1,0x13b9,0x13c1,
+0x13c9,0x13d1,0x13d9,0x13e1,0x1759,0x17b0,0x18f2,0x1a48,0x13f1,0x13f8,0x1400,0x1408,0x13e9,0x1410,0x1761,0x1768,
+0x166e,0x166e,0x166e,0x166e,0x166e,0x166e,0x166e,0x166e,0x1770,0x1773,0x1770,0x1770,0x177b,0x1782,0x1784,0x178b,
+0x1793,0x1797,0x1797,0x179a,0x1797,0x1797,0x17a0,0x1797,0x17e0,0x18a0,0x18fa,0xb8f,0xb95,0x1b7a,0xb9b,0xba0,
+0x1840,0xc4d,0xc51,0x18b5,0x1830,0x1830,0x1830,0xc25,0x1838,0xc45,0x1880,0xc9b,0xc2d,0xc35,0xc35,0x193e,
+0x1870,0x1902,0xc87,0xc8b,0x9ff,0x1676,0x1676,0xa07,0x167e,0x167e,0x167e,0x167e,0x167e,0x167e,0xa0f,0x6dd,
+0x14d8,0x14fa,0xa17,0x1502,0xa1f,0x150a,0x1512,0x151a,0xa27,0xa2c,0x1522,0x1529,0xa31,0xa39,0x1890,0xc15,
+0xa41,0x1580,0x1587,0x1531,0x158f,0x1596,0x1539,0xa49,0x1552,0x1552,0x1554,0x1541,0x1549,0x1549,0x154a,0x159e,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x1686,0x122b,0x17e8,0x17e8,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,
+0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x155c,0x1563,0x199f,0x1233,
+0x168e,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,
+0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,0x1694,
+0x1694,0x1694,0x1694,0x1694,0xa51,0x169c,0xa59,0x19bf,0x194a,0x194a,0x194a,0x194a,0x194a,0x194a,0x194a,0x194a,
+0x1946,0xd0c,0x195a,0x1952,0x195c,0x19c7,0x19c7,0xda0,0x1848,0x18bd,0x1912,0x1916,0x190a,0xcbb,0xcc2,0xcc5,
+0x1878,0xc93,0x18c5,0xccd,0x1964,0x1967,0xd14,0x19cf,0x1977,0x196f,0xd1c,0xda8,0x19d7,0x19db,0xdb0,0x100d,
+0x197f,0xd24,0xd2c,0x19e3,0x19f3,0x19eb,0xdb8,0xf09,0xe57,0xe5f,0x1bc1,0xfc5,0x1c66,0x1c66,0x19fb,0xdc0,
+0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,
+0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,
+0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,
+0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,
+0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,
+0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,
+0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,
+0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,
+0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,
+0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,
+0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,
+0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,
+0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,
+0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,
+0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,
+0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,
+0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,
+0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,
+0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,
+0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,
+0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,
+0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0x15f4,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,0x15f3,0xa61,0xdc8,0xdcb,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,
+0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,
+0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x14c3,0x156b,0x156b,0x156b,0x156b,0x156b,0x156b,0x156b,0x156b,
+0x1570,0x1578,0x17a8,0x123b,0x1888,0x1888,0x123f,0x1246,0xa69,0xa71,0xa79,0x1430,0x1437,0x143f,0xa81,0x1447,
+0x1478,0x1478,0x1420,0x1428,0x144f,0x146f,0x1470,0x1480,0x1457,0x1418,0xa89,0x145f,0xa91,0x1467,0xa99,0xa9d,
+0xca3,0x1488,0xaa5,0xaad,0x1490,0x1496,0x149b,0xab5,0xac5,0x14e0,0x14e8,0x14cb,0x14d0,0xacd,0xad5,0xabd,
+0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,
+0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15b6,0x15be,0x15be,0x15be,0x15be,
+0x13d4,0x13d4,0x1414,0x1454,0x1494,0x14d4,0x1514,0x1554,0x1590,0x15d0,0x15fc,0x163c,0x167c,0x16bc,0x16fc,0x173c,
+0x177c,0x17b8,0x17f8,0x1838,0x1878,0x18ac,0x18e8,0x1928,0x1968,0x19a8,0x19e4,0x1a24,0x1a64,0x1aa4,0x1ae4,0x1b24,
+0xa80,0xac0,0xb00,0xb40,0xb80,0xa40,0xbc0,0xa40,0xea8,0xa40,0xa40,0xa40,0xa40,0xc00,0x12d3,0x12d3,
+0xee8,0xf28,0xa40,0xa40,0xa40,0xa40,0xc40,0xc60,0xa40,0xa40,0xca0,0xce0,0xd20,0xd60,0xe68,0xdd8,
+0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,0x1213,
+0x1213,0x1213,0x1213,0x1213,0xf68,0x1253,0x1088,0x10c8,0x1293,0x10d3,0x1313,0x1313,0x1313,0xfa8,0xfc8,0x1008,
+0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,
+0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0xfc8,0x1048,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
 0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
-0xd9d,0xdad,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
-0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd1d,
-0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,
-0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x1150,0x10d0,
-0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,
-0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1190,0x1110,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0xb83,0xb8a,0xb92,0xb9a,0x1787,0x1787,0x1787,0xba2,0xbaa,0xbad,0x17b7,0x17af,0xbe0,0xd0d,0xd11,0xd15,
-0x4e4,0x4e4,0x4e4,0x4e4,0xd1d,0x191e,0xd25,0xf45,0x163b,0xab0,0xab6,0x1003,0xbb5,0x17ef,0xc5a,0x4e4,
-0x1650,0x1643,0x1648,0x178f,0xbbd,0xbc5,0x115c,0x1162,0x1b2f,0xf62,0x1b1f,0x6dc,0x4e4,0x4e4,0x4e4,0x4e4,
-0x1b4f,0x1b4f,0x1b4f,0x1b4f,0x1b4f,0x1b4f,0x1b4f,0x1b4f,0x1b4f,0xfb3,0xfbb,0xfc3,0x4e4,0x4e4,0x4e4,0x4e4,
-0xbcd,0xbd0,0xdb4,0x1b97,0xffb,0x6e4,0x4e4,0x1094,0xcae,0xd2d,0x4e4,0x4e4,0x1ae4,0xef8,0xf00,0x1bd7,
-0xc34,0xc3b,0xc43,0x1992,0x1b77,0x4e4,0x1b57,0xfd3,0x199a,0xdbc,0xdc4,0xdcc,0x1023,0x6ec,0x4e4,0x4e4,
-0x19a2,0x19a2,0x6f4,0x4e4,0x1c04,0x10ac,0x1bfc,0x10b4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0xdd4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x19f7,0x19f9,0xe4e,0xe55,0x19aa,0x19b2,0xddc,0xf25,0x1adc,0xee0,0xee8,0xfcb,0x1af4,0x1af8,0xf1d,0x1043,
-0xf96,0xf9b,0x6fc,0x4e4,0x109c,0x10a4,0x1b3f,0xfa3,0xf78,0xf7e,0xf86,0xf8e,0x4e4,0x4e4,0x4e4,0x4e4,
-0x1c44,0x1c3c,0x114c,0x1154,0x1bbf,0x1bb7,0x106a,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1ba7,0x102b,0x1033,0x103b,
-0x1b6f,0x1b67,0xfe3,0x1144,0x1b00,0xf35,0x704,0x4e4,0x107a,0x1082,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x1bcf,0x1bc7,0x1072,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1c6c,0x1c64,0x11a6,0x1c5c,0x119e,
-0x70c,0x1b9f,0x101b,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x110a,0x110f,0x1117,0x111e,0x1136,
-0x113c,0x4e4,0x4e4,0x1182,0x1186,0x118e,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1864,0x1864,0x1864,0x1864,0x1864,
-0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,
-0x1864,0x1864,0x1864,0x1864,0x1864,0x1864,0x1869,0xcb6,0xcbd,0xcbd,0xcbd,0x1871,0x1871,0x1871,0xcc5,0x1bf4,
-0x1bf4,0x1bf4,0x1bf4,0x1bf4,0x1bf4,0x714,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,
-0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19bc,0x19ba,0x19c4,
-0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x19c7,0x19ba,0x19ba,0x19ba,0x19ba,0x19ba,0x71c,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,
-0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0x1a01,0xe5d,0xfeb,0x724,0x4e4,
-0x4e4,0x728,0xf3d,0x1b8f,0x1b87,0x100b,0x1013,0x730,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x1aec,0x1aec,0xf08,0xf0d,0xf15,0x4e4,0x4e4,0x112e,0x1a11,0x1c74,0x1c74,0x1c74,0x1c74,
-0x1c74,0x1c74,0x1c74,0x117a,0x738,0x4e4,0x73c,0x1c84,0x1c84,0x1c84,0x1c84,0x1c84,0x1c84,0x1c84,0x1c84,0x1c84,
-0x1c84,0x1c84,0x1196,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1b27,0x1b27,0x1b27,0xf55,0xf5a,
-0x744,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1658,0x1658,0x1658,0x1658,0x1658,
-0x1658,0x1658,0xabe,0x1668,0xac6,0x1669,0x1660,0x1671,0x1677,0x167f,0xace,0x17a7,0x17a7,0x74c,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x1797,0x1797,0xbd8,0xccd,0x4e4,0x4e4,0x4e4,0x4e4,0x16b0,0x16b7,0xad6,0x16ba,0xade,
-0xae6,0xaee,0x16b4,0xaf6,0xafe,0xb06,0x16b9,0x16c1,0x16b0,0x16b7,0x16b3,0x16ba,0x16c2,0x16b1,0x16b8,0x16b4,
-0xb0d,0x1687,0x168f,0x1696,0x169d,0x168a,0x1692,0x1699,0x16a0,0xb15,0x16a8,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,
-0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c1c,0x1c0c,0x1c0f,0x1c0c,0x1c16,0x10fa,
-0x754,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1126,0x75c,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x760,0x104b,0x1baf,0x1051,
-0x1baf,0x1059,0x105e,0x1062,0x1062,0x10bc,0x10c4,0x10cc,0x10d4,0x10dc,0x10e2,0x10ea,0x10f2,0x768,0x768,0x768,
-0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,
-0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,
-0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x768,0x769,0xb1d,0x16ca,0x16ca,
-0x16ca,0x771,0x771,0x771,0x771,0x179f,0x179f,0x179f,0x179f,0x179f,0x179f,0x179f,0x779,0x771,0x771,0x771,
-0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,
-0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,
-0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,
-0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x1926,0xd35,0x192e,
-0x192e,0xd39,0xe65,0xe6d,0xe75,0xde4,0xdea,0x19df,0xdf2,0x19d7,0xdfa,0xdfe,0xe05,0xe0d,0xe14,0xe1c,
-0xe24,0xe26,0xe26,0xe26,0xe26,0x1a38,0x1a40,0x1a48,0x1a4c,0x1a54,0x1a19,0x1a5c,0x1a64,0x1a48,0x1a6c,0x1a74,
-0x1a7b,0x1a83,0x1a21,0x1a48,0x1a86,0x1a29,0x1a30,0x1a8e,0x1a94,0x1b10,0x1b17,0x1b08,0x1a9c,0x1aa4,0x1aac,0x1ab4,
-0x1b7f,0x1abc,0x1ac4,0xe7d,0xe85,0x1a09,0x1a09,0x1a09,0xe8d,0x1b37,0x1b37,0xf6a,0xf70,0x1b5f,0x1b5f,0x1b5f,
-0x1b5f,0x1b5f,0x1b5f,0xfdb,0x4e4,0x1c34,0x1c2c,0x1102,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0xea5,0xead,0xeb5,
-0xebd,0xec5,0xecd,0xed4,0xed8,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,0x1bdf,
-0x1bdf,0x1bdf,0x1bdf,0x1be4,0x1bdf,0x1bdf,0x1bdf,0x108a,0x108c,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x116a,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,
-0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1c54,0x1172,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,
-0x4e4,0x4e4,0x4e4,0x4e4,0x4e4,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x11e5,0x11ae,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x11b6,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,0x16da,
-0x16da,0x16da,0x16da,0x16da,0x16da,0x11ed,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ba,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,0x11ae,
-0x11ae,0x11ae,0x11ae,0x11ae,0x11ba,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x11f5,0x1acc,
-0x1acc,0x1acc,0x1acc,0x1acc,0x1acc,0x11fd,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1205,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1565,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x156d,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,0x157d,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,0x16d2,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,0x19e7,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,0x1c24,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,0x1c4c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,0x1c7c,
-0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x285,0x28e,0x288,0x288,0x28b,0x282,0x282,
-0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,
-0x7b3,0x7ad,0x792,0x789,0x780,0x77d,0x774,0x78f,0x77a,0x786,0x789,0x7a4,0x79b,0x78c,0x7b0,0x783,
-0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x771,0x798,0x795,0x79e,0x79e,0x79e,0x7ad,
-0x774,0x7bf,0x7bf,0x7bf,0x7bf,0x7bf,0x7bf,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,
-0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x7b9,0x77a,0x780,0x786,0x7aa,0x76e,
-0x7a7,0x7bc,0x7bc,0x7bc,0x7bc,0x7bc,0x7bc,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,
-0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x7b6,0x77a,0x7a1,0x777,0x79e,0x282,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x291,0x291,0x291,0x291,0x291,0x2a0,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,
-0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,0x291,
-0x294,0x609,0x7c8,0x7cb,0x60f,0x7cb,0x7c5,0x606,0x5fd,0x29a,0x61b,0x29d,0x7ce,0x5f4,0x612,0x7c2,
-0x60c,0x618,0x5fa,0x5fa,0x600,0x297,0x606,0x603,0x5fd,0x5fa,0x61b,0x29d,0x5f7,0x5f7,0x5f7,0x609,
-0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x624,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,
-0x624,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x615,0x624,0x2a6,0x2a6,0x2a6,0x2a6,0x2a6,0x624,0x61e,
-0x621,0x621,0x2a3,0x2a3,0x2a3,0x2a3,0x61e,0x2a3,0x621,0x621,0x621,0x2a3,0x621,0x621,0x2a3,0x2a3,
-0x61e,0x2a3,0x621,0x621,0x2a3,0x2a3,0x2a3,0x615,0x61e,0x621,0x621,0x2a3,0x621,0x2a3,0x61e,0x2a3,
-0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,
-0x2af,0x627,0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x2a9,
-0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x630,0x627,0x2b2,0x2a9,0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x2a9,
-0x2b2,0x627,0x633,0x62d,0x2b2,0x2a9,0x2b2,0x2a9,0x627,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x633,
-0x62d,0x630,0x627,0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x62a,0x636,0x630,0x627,0x2b2,0x62a,0x2b2,0x2a9,
-0x2b2,0x2a9,0x630,0x627,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,
-0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x630,0x627,0x2b2,0x2a9,0x2b2,0x62a,0x2b2,0x2a9,0x2b2,0x2a9,
-0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2b2,0x2a9,0x2b2,0x2a9,0x2b2,0x2a9,0x2ac,
-0x2b5,0x2c1,0x2c1,0x2b5,0x2c1,0x2b5,0x2c1,0x2c1,0x2b5,0x2c1,0x2c1,0x2c1,0x2b5,0x2b5,0x2c1,0x2c1,
-0x2c1,0x2c1,0x2b5,0x2c1,0x2c1,0x2b5,0x2c1,0x2c1,0x2c1,0x2b5,0x2b5,0x2b5,0x2c1,0x2c1,0x2b5,0x2c1,
-0x2c4,0x2b8,0x2c1,0x2b5,0x2c1,0x2b5,0x2c1,0x2c1,0x2b5,0x2c1,0x2b5,0x2b5,0x2c1,0x2b5,0x2c1,0x2c4,
-0x2b8,0x2c1,0x2c1,0x2c1,0x2b5,0x2c1,0x2b5,0x2c1,0x2c1,0x2b5,0x2b5,0x2be,0x2c1,0x2b5,0x2b5,0x2b5,
-0x2be,0x2be,0x2be,0x2be,0x2c7,0x2c7,0x2bb,0x2c7,0x2c7,0x2bb,0x2c7,0x2c7,0x2bb,0x2c4,0x639,0x2c4,
-0x639,0x2c4,0x639,0x2c4,0x639,0x2c4,0x639,0x2c4,0x639,0x2c4,0x639,0x2c4,0x639,0x2b5,0x2c4,0x2b8,
-0x2c4,0x2b8,0x2c4,0x2b8,0x2c1,0x2b5,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,
-0x2b8,0x2c7,0x2c7,0x2bb,0x2c4,0x2b8,0x9a2,0x9a2,0x9a5,0x99f,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,
-0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,0x2c4,0x2b8,
-0x2c4,0x2b8,0x2c4,0x2b8,0x9a5,0x99f,0x9a5,0x99f,0x9a2,0x99c,0x9a5,0x99f,0xb61,0xc63,0x9a2,0x99c,
-0x9a2,0x99c,0x9a5,0x99f,0x9a5,0x99f,0x9a5,0x99f,0x9a5,0x99f,0x9a5,0x99f,0x9a5,0x99f,0x9a5,0x99f,
-0xc63,0xc63,0xc63,0xd5c,0xd5c,0xd5c,0xd5f,0xd5f,0xd5c,0xd5f,0xd5f,0xd5c,0xd5c,0xd5f,0xea3,0xea6,
-0xea6,0xea6,0xea6,0xea3,0xea6,0xea3,0xea6,0xea3,0xea6,0xea3,0xea6,0xea3,0x2ca,0x63c,0x2ca,0x2ca,
-0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x63c,0x2ca,0x2ca,
-0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,
-0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2cd,0x2ca,0x2ca,0x2ca,
-0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,0x2ca,
-0x2ca,0x9a8,0x9a8,0x9a8,0x9a8,0x9a8,0xc66,0xc66,0x2e5,0x2e5,0x2e5,0x2e5,0x2e5,0x2e5,0x2e5,0x2e5,
-0x2e5,0x2dc,0x2dc,0x2dc,0x2dc,0x2dc,0x2dc,0x2dc,0x2d9,0x2d9,0x2d6,0x2d6,0x642,0x2d6,0x2dc,0x645,
-0x2df,0x645,0x645,0x645,0x2df,0x645,0x2dc,0x2dc,0x648,0x2e2,0x2d6,0x2d6,0x2d6,0x2d6,0x2d6,0x2d6,
-0x63f,0x63f,0x63f,0x63f,0x2d3,0x63f,0x2d6,0xada,0x2e5,0x2e5,0x2e5,0x2e5,0x2e5,0x2d0,0x2d0,0x2d0,
-0x2d0,0x2d0,0x9b1,0x9b1,0x9ae,0x9ab,0x9ae,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,
-0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0xc69,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,
-0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,
-0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,
-0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,
-0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64b,0x64e,0x64e,0x906,0x64e,0x64e,0x909,0xadd,0xadd,
-0xadd,0xadd,0xadd,0xadd,0xadd,0xadd,0xadd,0xc1b,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,
-0xe6a,0xe6a,0xe6a,0xe6a,0xe6d,0xd2f,0xd2f,0xd2f,0x651,0x651,0xae0,0xc60,0xc60,0xc60,0xc60,0xc60,
-0xc60,0xc60,0xc60,0xc60,0xc60,0xc60,0xc60,0xc60,0xf51,0xf4e,0xf51,0xf4e,0x2f1,0x2fa,0xf51,0xf4e,
-9,9,0x300,0xea9,0xea9,0xea9,0x2e8,0x14a6,9,9,9,9,0x2fd,0x2eb,0x30f,0x2ee,
-0x30f,0x30f,0x30f,9,0x30f,9,0x30f,0x30f,0x306,0x657,0x657,0x657,0x657,0x657,0x657,0x657,
-0x657,0x657,0x657,0x657,0x657,0x657,0x657,0x657,0x657,0x657,9,0x657,0x657,0x657,0x657,0x657,
-0x657,0x657,0x30f,0x30f,0x306,0x306,0x306,0x306,0x306,0x654,0x654,0x654,0x654,0x654,0x654,0x654,
-0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x654,0x303,0x654,0x654,0x654,0x654,0x654,
-0x654,0x654,0x306,0x306,0x306,0x306,0x306,0xf51,0x312,0x312,0x315,0x30f,0x30f,0x312,0x309,0x9b4,
-0xb6a,0xb67,0x30c,0x9b4,0x30c,0x9b4,0x30c,0x9b4,0x30c,0x9b4,0x2f7,0x2f4,0x2f7,0x2f4,0x2f7,0x2f4,
-0x2f7,0x2f4,0x2f7,0x2f4,0x2f7,0x2f4,0x2f7,0x2f4,0x312,0x312,0x309,0x303,0xb19,0xb16,0xb64,0xc6f,
-0xc6c,0xc72,0xc6f,0xc6c,0xd62,0xd65,0xd65,0xd65,0x9c3,0x663,0x321,0x324,0x321,0x321,0x321,0x324,
-0x321,0x321,0x321,0x321,0x324,0x9c3,0x324,0x321,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,
-0x660,0x663,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,
-0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x660,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,
-0x65a,0x65d,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,0x65a,
-0x65a,0x65a,0x65a,0x65a,0x9bd,0x65d,0x31b,0x31e,0x31b,0x31b,0x31b,0x31e,0x31b,0x31b,0x31b,0x31b,
-0x31e,0x9bd,0x31e,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,
-0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x324,0x31e,0x321,0x31b,0x321,0x31b,
-0x321,0x31b,0x321,0x31b,0x321,0x31b,0x318,0x912,0x915,0x8f7,0x8f7,0x10fb,0x9b7,0x9b7,0xb70,0xb6d,
-0x9c0,0x9ba,0x9c0,0x9ba,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,
-0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,
-0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,0x321,0x31b,
-0x321,0x31b,0x321,0x31b,0x321,0x324,0x31e,0x321,0x31b,0xb70,0xb6d,0x321,0x31b,0xb70,0xb6d,0x321,
-0x31b,0xb70,0xb6d,0xeac,0x324,0x31e,0x324,0x31e,0x321,0x31b,0x324,0x31e,0x321,0x31b,0x324,0x31e,
-0x324,0x31e,0x324,0x31e,0x321,0x31b,0x324,0x31e,0x324,0x31e,0x324,0x31e,0x321,0x31b,0x324,0x31e,
-0x9c3,0x9bd,0x324,0x31e,0x324,0x31e,0x324,0x31e,0x324,0x31e,0xd6b,0xd68,0x324,0x31e,0xeaf,0xeac,
-0xeaf,0xeac,0xeaf,0xeac,0xbdc,0xbd9,0xbdc,0xbd9,0xbdc,0xbd9,0xbdc,0xbd9,0xbdc,0xbd9,0xbdc,0xbd9,
-0xbdc,0xbd9,0xbdc,0xbd9,0xedc,0xed9,0xedc,0xed9,0xfcf,0xfcc,0xfcf,0xfcc,0xfcf,0xfcc,0xfcf,0xfcc,
-0xfcf,0xfcc,0xfcf,0xfcc,0xfcf,0xfcc,0xfcf,0xfcc,0x1134,0x1131,0x130e,0x130b,0x14df,0x14dc,0x14df,0x14dc,
-0x14df,0x14dc,0x14df,0x14dc,0xc,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,
-0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0x333,0xc,
-0xc,0x336,0x327,0x327,0x327,0x32a,0x327,0x327,0xc,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,
-0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,
-0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x32d,0x330,0xc,0x87c,0x9c6,0xc,
-0xc,0x14a9,0x14a9,0x13c2,0xf,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,
-0x936,0x936,0x936,0x936,0x936,0x936,0xd6e,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,0x936,
-0x936,0x936,0x936,0x936,0x339,0x339,0x339,0x339,0x339,0x339,0x339,0x339,0x339,0x339,0xeb2,0x339,
-0x339,0x339,0x345,0x339,0x33c,0x339,0x339,0x348,0x939,0xd71,0xd74,0xd71,0xf,0xf,0xf,0xf,
-0xf,0xf,0xf,0xf,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,
-0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0x34b,0xf,
-0xf,0xf,0xf,0xf,0x34b,0x34b,0x34b,0x342,0x33f,0xf,0xf,0xf,0xf,0xf,0xf,0xf,
-0xf,0xf,0xf,0xf,0xc87,0xc87,0xc87,0xc87,0x13c5,0x14ac,0xf5a,0xf5a,0xf5a,0xf57,0xf57,0xd7d,
-0x882,0xc81,0xc7e,0xc7e,0xc75,0xc75,0xc75,0xc75,0xc75,0xc75,0xf54,0xf54,0xf54,0xf54,0xf54,0x87f,
-0x14a3,0x12,0xd7a,0x885,0x12d5,0x366,0x369,0x369,0x369,0x369,0x369,0x366,0x366,0x366,0x366,0x366,
-0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0xf5d,
-0xf5d,0xf5d,0xf5d,0xf5d,0x888,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x8fd,
-0x8fd,0x8fd,0x8fd,0x8fd,0x8fd,0x8fd,0x8fd,0xb10,0xb10,0xb10,0xc75,0xc7b,0xc78,0xd77,0xd77,0xd77,
-0xd77,0xd77,0xd77,0x12d2,0x918,0x918,0x918,0x918,0x918,0x918,0x918,0x918,0x918,0x918,0x360,0x35d,
-0x35a,0x357,0xb73,0xb73,0x8fa,0x366,0x366,0x372,0x366,0x36c,0x36c,0x36c,0x36c,0x366,0x366,0x366,
-0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,
-0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,
-0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,
-0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x9cc,0x9cc,0x366,0x366,0x366,0x366,0x366,0x9cc,
-0x369,0x366,0x369,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x366,0x9cc,
-0x366,0x366,0x366,0x369,0x375,0x366,0x351,0x351,0x351,0x351,0x351,0x351,0x351,0x34e,0x357,0x354,
-0x354,0x351,0x351,0x351,0x351,0x36f,0x36f,0x351,0x351,0x357,0x354,0x354,0x354,0x351,0xc84,0xc84,
-0x363,0x363,0x363,0x363,0x363,0x363,0x363,0x363,0x363,0x363,0x9cc,0x9cc,0x9cc,0x9c9,0x9c9,0xc84,
-0x9e1,0x9e1,0x9e1,0x9db,0x9db,0x9db,0x9db,0x9db,0x9db,0x9db,0x9db,0x9d8,0x9db,0x9d8,0x15,0x9e4,
-0x9de,0x9cf,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,
-0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0x9de,0xc8a,0xc8a,0xc8a,
-0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,0x9d5,
-0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x9d2,0x15,0x15,0xc8a,0xc8a,0xc8a,
-0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,
-0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xde0,0xfe1,0xfe1,
-0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,0xfe1,
-0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,
-0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,
-0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9ea,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,0x9e7,
-0x9e7,0xb76,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0xef4,0xef4,0xef4,0xef4,0xef4,0xef4,0xef4,0xef4,0xef4,0xef4,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,
-0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,
-0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xef7,0xeeb,0xeeb,0xeeb,0xeeb,0xeeb,
-0xeeb,0xeeb,0xeeb,0xeeb,0xefa,0xefa,0xeee,0xeee,0xef1,0xf00,0xefd,0x10e,0x10e,0x10e,0x10e,0x10e,
-0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x25e,0x25e,0x25e,0x25e,0x25e,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x17e8,0x17e8,0x17e8,0x17e8,0x17e8,0x17e8,0x17e8,0x17e8,0x17e8,0x237,0x237,0x237,0x237,0x237,0x237,0x237,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xaec,0xaec,0xaef,0xaef,0xaec,0xaec,0xaec,0xaec,0xaec,0xaec,0xaec,0xaec,0x72,0x72,0x72,0x72,
-0x1563,0x1563,0x1563,0x1563,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1c5,0x1560,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1f8,0x1f8,0x1f8,0x1f8,0x1f8,0x1f8,0x1f8,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,0x161d,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x204,0x204,0x204,0x204,0x204,0x204,0x204,0x204,0x204,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x17a,0x17a,0x17a,0x17a,0x17a,0x17a,0x17a,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
+0xe18,0xe28,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,
+0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xa40,0xd98,
+0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,
+0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1193,0x1113,
+0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,
+0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x11d3,0x1153,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0xba8,0xbaf,0xbb7,0xbbf,0x17f0,0x17f0,0x17f0,0xbc7,0xbcf,0xbd2,0x1820,0x1818,0xc05,0xd34,0xd38,0xd3c,
+0x4f5,0x4f5,0x4f5,0x4f5,0xd44,0x1987,0xd4c,0xf5e,0x16a4,0xadd,0xae3,0x101d,0xbda,0x1858,0xc7f,0x4f5,
+0x16b9,0x16ac,0x16b1,0x17f8,0xbe2,0xbea,0x1168,0x116e,0x1ba9,0xf7b,0x1b99,0x6e5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1bc9,0x1bc9,0x1bc9,0x1bc9,0x1bc9,0x1bc9,0x1bc9,0x1bc9,0x1bc9,0xfcd,0xfd5,0xfdd,0x4f5,0x4f5,0x4f5,0x4f5,
+0xbf2,0xbf5,0xdd3,0x1c11,0x1015,0x6ed,0x4f5,0x10ae,0xcd5,0xd54,0x4f5,0x4f5,0x1b56,0xf11,0xf19,0x1c51,
+0xc59,0xc60,0xc68,0x1a03,0x1bf1,0x4f5,0x1bd1,0xfed,0x1a0b,0xddb,0xde3,0xdeb,0x103d,0x6f5,0x4f5,0x4f5,
+0x1a13,0x1a13,0x6fd,0x4f5,0x1c7e,0x10c6,0x1c76,0x10ce,0x1d26,0x11e0,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0xdf3,0x4f5,0x4f5,0x4f5,0x4f5,0x1d46,0x1208,0x120f,0x705,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1a70,0x1a72,0xe67,0xe6e,0x1a1b,0x1a23,0xdfb,0xf3e,0x1b4e,0xef9,0xf01,0xfe5,0x1b66,0x1b6a,0xf36,0x105d,
+0xfb0,0xfb5,0x70d,0x4f5,0x10b6,0x10be,0x1bb9,0xfbd,0xf92,0xf98,0xfa0,0xfa8,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1cc6,0x1cbe,0x1158,0x1160,0x1c39,0x1c31,0x1084,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x1c21,0x1045,0x104d,0x1055,
+0x1be9,0x1be1,0xffd,0x1150,0x1b72,0xf4e,0x715,0x4f5,0x1094,0x109c,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1d1e,0x11c2,0x71d,0x4f5,0x4f5,0x1c49,0x1c41,0x108c,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1cf6,0x1cee,0x11b2,0x1ce6,0x11aa,0x725,0x1c19,0x1035,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x110e,0x1113,0x111b,0x1122,0x1142,0x1148,0x4f5,0x4f5,0x118e,0x1192,0x119a,0x11d2,0x11d8,0x72d,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x11f0,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,
+0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18cd,0x18d2,0xcdd,0xce4,0xce4,0xce4,
+0x18da,0x18da,0x18da,0xcec,0x1c6e,0x1c6e,0x1c6e,0x1c6e,0x1c6e,0x1c6e,0x735,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,
+0x1a2b,0x1a2b,0x1a2d,0x1a2b,0x1a35,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a2b,0x1a38,0x1a2b,0x1a2b,0x1a2b,0x1a2b,
+0x1a2b,0x73d,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,0x1a7a,
+0x1a7a,0xe76,0x1005,0x745,0x4f5,0x4f5,0x749,0xf56,0x1c09,0x1c01,0x1025,0x102d,0x751,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x1d3e,0x1d36,0x1200,0x4f5,0x4f5,0x4f5,0x1b5e,0x1b5e,0xf21,0xf26,0xf2e,0x4f5,0x4f5,0x113a,
+0x1a8a,0x1cfe,0x1cfe,0x1cfe,0x1cfe,0x1cfe,0x1cfe,0x1cfe,0x1186,0x759,0x4f5,0x75d,0x1d16,0x1d16,0x1d16,0x1d16,
+0x1d16,0x1d16,0x1d16,0x1d16,0x1d16,0x1d16,0x1d16,0x11a2,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1ba1,0x1ba1,0x1ba1,0xf6e,0xf73,0x765,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x16c1,0x16c1,0x16c1,0x16c1,0x16c1,0x16c1,0x16c1,0xaeb,0x16d1,0xaf3,0x16d2,0x16c9,0x16da,0x16e0,0x16e8,0xafb,
+0x1810,0x1810,0x76d,0x4f5,0x4f5,0x4f5,0x4f5,0x11f8,0x1800,0x1800,0xbfd,0xcf4,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1719,0x1720,0xb03,0x1723,0xb0b,0xb13,0xb1b,0x171d,0xb23,0xb2b,0xb33,0x1722,0x172a,0x1719,0x1720,0x171c,
+0x1723,0x172b,0x171a,0x1721,0x171d,0xb3a,0x16f0,0x16f8,0x16ff,0x1706,0x16f3,0x16fb,0x1702,0x1709,0xb42,0x1711,
+0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,0x1c96,
+0x1c86,0x1c89,0x1c86,0x1c90,0x10fe,0x775,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1132,0x77d,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x1bd9,0x1bd9,0x1bd9,0x1bd9,0x1bd9,0x1bd9,0xff5,0x4f5,0x1cb6,0x1cae,0x1106,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x781,0x1d2e,0x11e8,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0xebe,0xec6,0xece,0xed6,0xede,0xee6,0xeed,0xef1,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x789,0x1065,0x1c29,0x106b,0x1c29,0x1073,0x1078,0x107c,0x107c,
+0x10d6,0x10de,0x1cce,0x10e6,0x1ca6,0x10ee,0x10f6,0x1d06,0x11ba,0x11ba,0x11ba,0x791,0x795,0x795,0x795,0x795,
+0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,
+0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x795,
+0x795,0x795,0x795,0x795,0x795,0x795,0x795,0x796,0xb4a,0x1733,0x1733,0x1733,0x79e,0x79e,0x79e,0x79e,
+0x1808,0x1808,0x1808,0x1808,0x1808,0x1808,0x1808,0x7a6,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,
+0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,
+0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,
+0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,
+0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x79e,0x198f,0xd5c,0x1997,0x1997,0xd60,0xe7e,0xe86,0xe8e,
+0xe03,0x1a40,0x1a58,0xe0b,0x1a50,0xe13,0xe17,0xe1e,0xe26,0xe2d,0xe35,0xe3d,0xe3f,0xe3f,0xe3f,0xe3f,
+0x1ab1,0x1ab9,0x1ab1,0x1abf,0x1ac7,0x1a92,0x1acf,0x1ad7,0x1ab1,0x1adf,0x1ae7,0x1aee,0x1af6,0x1a9a,0x1ab1,0x1af8,
+0x1aa2,0x1aa9,0x1b00,0x1b06,0x1b8a,0x1b91,0x1b82,0x1b0e,0x1b16,0x1b1e,0x1b26,0x1bf9,0x1b2e,0x1b36,0xe96,0xe9e,
+0x1a82,0x1a82,0x1a82,0xea6,0x1bb1,0x1bb1,0xf83,0xf8a,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,
+0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,0x1c59,0x1c5e,0x1c59,0x1c59,0x1c59,0x10a4,0x10a6,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1176,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,
+0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x1cde,0x117e,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,
+0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x4f5,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x124e,0x1217,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x121f,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,
+0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,0x1743,0x1256,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1223,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,
+0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1217,0x1223,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x125e,0x1b3e,0x1b3e,0x1b3e,0x1b3e,0x1b3e,0x1b3e,0x1266,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x126e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15ce,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15d6,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,
+0x15de,0x15de,0x15de,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,0x15e6,
+0x15e6,0x15e6,0x15e6,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,0x173b,
+0x173b,0x173b,0x173b,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,0x1a60,
+0x1a60,0x1a60,0x1a60,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,0x1c9e,
+0x1c9e,0x1c9e,0x1c9e,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,0x1cd6,
+0x1cd6,0x1cd6,0x1cd6,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,0x1d0e,
+0x1d0e,0x1d0e,0x1d0e,0x4d4,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a3,0x2ac,0x2a6,
+0x2a6,0x2a9,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,0x2a0,
+0x2a0,0x2a0,0x2a0,0x2a0,0x7d4,0x7ce,0x7b3,0x7aa,0x7a1,0x79e,0x795,0x7b0,0x79b,0x7a7,0x7aa,0x7c5,
+0x7bc,0x7ad,0x7d1,0x7a4,0x792,0x792,0x792,0x792,0x792,0x792,0x792,0x792,0x792,0x792,0x7b9,0x7b6,
+0x7bf,0x7bf,0x7bf,0x7ce,0x795,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,0x7da,0x7da,0x7da,0x7da,0x7da,
+0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x7da,0x79b,
+0x7a1,0x7a7,0x7cb,0x78f,0x7c8,0x7dd,0x7dd,0x7dd,0x7dd,0x7dd,0x7dd,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,
+0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x7d7,0x79b,
+0x7c2,0x798,0x7bf,0x2a0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,0x1da,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1890,0x1893,0x1893,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,0x25b,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1752,0x1752,0x1752,0x1752,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,0x21f,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x183,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1f2,0x1f2,0x1f2,0x1f2,0x160e,0x160e,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,
-0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0x16bc,0x16bc,0x16bc,0x16bc,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0xdd7,0xdd7,0xdd4,0xdd4,0xdd4,0xdd7,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x22e,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x17eb,0x17eb,0x23a,0x17eb,0x17eb,0x23a,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x23a,0x23a,0x23a,0x23a,0x23a,
+0,0,0,0,0x2af,0x2af,0x2af,0x2af,0x2af,0x2be,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,
+0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,0x2af,
+0x2af,0x2af,0x2af,0x2af,0x2b2,0x62a,0x7e9,0x7ec,0x630,0x7ec,0x7e6,0x627,0x61e,0x2b8,0x63c,0x2bb,
+0x7ef,0x615,0x633,0x7e3,0x62d,0x639,0x61b,0x61b,0x621,0x2b5,0x627,0x624,0x61e,0x61b,0x63c,0x2bb,
+0x618,0x618,0x618,0x62a,0x2c4,0x2c4,0x2c4,0x2c4,0x2c4,0x2c4,0x645,0x2c4,0x2c4,0x2c4,0x2c4,0x2c4,
+0x2c4,0x2c4,0x2c4,0x2c4,0x645,0x2c4,0x2c4,0x2c4,0x2c4,0x2c4,0x2c4,0x636,0x645,0x2c4,0x2c4,0x2c4,
+0x2c4,0x2c4,0x645,0x63f,0x642,0x642,0x2c1,0x2c1,0x2c1,0x2c1,0x63f,0x2c1,0x642,0x642,0x642,0x2c1,
+0x642,0x642,0x2c1,0x2c1,0x63f,0x2c1,0x642,0x642,0x2c1,0x2c1,0x2c1,0x636,0x63f,0x642,0x642,0x2c1,
+0x642,0x2c1,0x63f,0x2c1,0x2d0,0x64b,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,
+0x2d0,0x2c7,0x2d0,0x2c7,0x2cd,0x648,0x2d0,0x64b,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x64b,
+0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x651,0x648,0x2d0,0x2c7,0x2d0,0x64b,
+0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x648,0x654,0x64e,0x2d0,0x2c7,0x2d0,0x2c7,0x648,0x2d0,0x2c7,0x2d0,
+0x2c7,0x2d0,0x2c7,0x654,0x64e,0x651,0x648,0x2d0,0x64b,0x2d0,0x2c7,0x2d0,0x64b,0x657,0x651,0x648,
+0x2d0,0x64b,0x2d0,0x2c7,0x2d0,0x2c7,0x651,0x648,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,
+0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x651,0x648,0x2d0,0x2c7,0x2d0,0x64b,
+0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2c7,0x2d0,0x2d0,0x2c7,0x2d0,
+0x2c7,0x2d0,0x2c7,0x2ca,0x2d3,0x2df,0x2df,0x2d3,0x2df,0x2d3,0x2df,0x2df,0x2d3,0x2df,0x2df,0x2df,
+0x2d3,0x2d3,0x2df,0x2df,0x2df,0x2df,0x2d3,0x2df,0x2df,0x2d3,0x2df,0x2df,0x2df,0x2d3,0x2d3,0x2d3,
+0x2df,0x2df,0x2d3,0x2df,0x2e2,0x2d6,0x2df,0x2d3,0x2df,0x2d3,0x2df,0x2df,0x2d3,0x2df,0x2d3,0x2d3,
+0x2df,0x2d3,0x2df,0x2e2,0x2d6,0x2df,0x2df,0x2df,0x2d3,0x2df,0x2d3,0x2df,0x2df,0x2d3,0x2d3,0x2dc,
+0x2df,0x2d3,0x2d3,0x2d3,0x2dc,0x2dc,0x2dc,0x2dc,0x2e5,0x2e5,0x2d9,0x2e5,0x2e5,0x2d9,0x2e5,0x2e5,
+0x2d9,0x2e2,0x65a,0x2e2,0x65a,0x2e2,0x65a,0x2e2,0x65a,0x2e2,0x65a,0x2e2,0x65a,0x2e2,0x65a,0x2e2,
+0x65a,0x2d3,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2df,0x2d3,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,
+0x2e2,0x2d6,0x2e2,0x2d6,0x2d6,0x2e5,0x2e5,0x2d9,0x2e2,0x2d6,0x9c3,0x9c3,0x9c6,0x9c0,0x2e2,0x2d6,
+0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,
+0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x2e2,0x2d6,0x9c6,0x9c0,0x9c6,0x9c0,0x9c3,0x9bd,0x9c6,0x9c0,
+0xb88,0xc90,0x9c3,0x9bd,0x9c3,0x9bd,0x9c6,0x9c0,0x9c6,0x9c0,0x9c6,0x9c0,0x9c6,0x9c0,0x9c6,0x9c0,
+0x9c6,0x9c0,0x9c6,0x9c0,0xc90,0xc90,0xc90,0xd8f,0xd8f,0xd8f,0xd92,0xd92,0xd8f,0xd92,0xd92,0xd8f,
+0xd8f,0xd92,0xed3,0xed6,0xed6,0xed6,0xed6,0xed3,0xed6,0xed3,0xed6,0xed3,0xed6,0xed3,0xed6,0xed3,
+0x2e8,0x65d,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,
+0x2e8,0x65d,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,
+0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,
+0x2eb,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,
+0x2e8,0x2e8,0x2e8,0x2e8,0x2e8,0x9c9,0x9c9,0x9c9,0x9c9,0x9c9,0xc93,0xc93,0x303,0x303,0x303,0x303,
+0x303,0x303,0x303,0x303,0x303,0x2fa,0x2fa,0x2fa,0x2fa,0x2fa,0x2fa,0x2fa,0x2f7,0x2f7,0x2f4,0x2f4,
+0x663,0x2f4,0x2fa,0x666,0x2fd,0x666,0x666,0x666,0x2fd,0x666,0x2fa,0x2fa,0x669,0x300,0x2f4,0x2f4,
+0x2f4,0x2f4,0x2f4,0x2f4,0x660,0x660,0x660,0x660,0x2f1,0x660,0x2f4,0xb01,0x303,0x303,0x303,0x303,
+0x303,0x2ee,0x2ee,0x2ee,0x2ee,0x2ee,0x9d2,0x9d2,0x9cf,0x9cc,0x9cf,0xc96,0xc96,0xc96,0xc96,0xc96,
+0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0xc96,0x66c,0x66c,0x66c,0x66c,
+0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,
+0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,
+0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,
+0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66c,0x66f,0x66f,0x927,0x66f,
+0x66f,0x92a,0xb04,0xb04,0xb04,0xb04,0xb04,0xb04,0xb04,0xb04,0xb04,0xc45,0xd5c,0xd5c,0xd5c,0xd5c,
+0xd5c,0xd5c,0xd5c,0xd5c,0xe9a,0xe9a,0xe9a,0xe9a,0xe9d,0xd5f,0xd5f,0xd5f,0x672,0x672,0xb07,0xc8d,
+0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xc8d,0xf81,0xf7e,0xf81,0xf7e,
+0x30f,0x318,0xf81,0xf7e,9,9,0x31e,0xed9,0xed9,0xed9,0x306,0x14d6,9,9,9,9,
+0x31b,0x309,0x32d,0x30c,0x32d,0x32d,0x32d,9,0x32d,9,0x32d,0x32d,0x324,0x678,0x678,0x678,
+0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,0x678,9,0x678,
+0x678,0x678,0x678,0x678,0x678,0x678,0x32d,0x32d,0x324,0x324,0x324,0x324,0x324,0x675,0x675,0x675,
+0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x675,0x321,0x675,
+0x675,0x675,0x675,0x675,0x675,0x675,0x324,0x324,0x324,0x324,0x324,0xf81,0x330,0x330,0x333,0x32d,
+0x32d,0x330,0x327,0x9d5,0xb91,0xb8e,0x32a,0x9d5,0x32a,0x9d5,0x32a,0x9d5,0x32a,0x9d5,0x315,0x312,
+0x315,0x312,0x315,0x312,0x315,0x312,0x315,0x312,0x315,0x312,0x315,0x312,0x330,0x330,0x327,0x321,
+0xb40,0xb3d,0xb8b,0xc9c,0xc99,0xc9f,0xc9c,0xc99,0xd95,0xd98,0xd98,0xd98,0x9e4,0x684,0x33f,0x342,
+0x33f,0x33f,0x33f,0x342,0x33f,0x33f,0x33f,0x33f,0x342,0x9e4,0x342,0x33f,0x681,0x681,0x681,0x681,
+0x681,0x681,0x681,0x681,0x681,0x684,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,
+0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x681,0x67b,0x67b,0x67b,0x67b,
+0x67b,0x67b,0x67b,0x67b,0x67b,0x67e,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,
+0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x67b,0x9de,0x67e,0x339,0x33c,0x339,0x339,0x339,0x33c,
+0x339,0x339,0x339,0x339,0x33c,0x9de,0x33c,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,
+0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x342,0x33c,
+0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x336,0x933,0x936,0x918,0x918,0x112b,
+0x9d8,0x9d8,0xb97,0xb94,0x9e1,0x9db,0x9e1,0x9db,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,
+0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,
+0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,
+0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x339,0x33f,0x342,0x33c,0x33f,0x339,0xb97,0xb94,0x33f,
+0x339,0xb97,0xb94,0x33f,0x339,0xb97,0xb94,0xedc,0x342,0x33c,0x342,0x33c,0x33f,0x339,0x342,0x33c,
+0x33f,0x339,0x342,0x33c,0x342,0x33c,0x342,0x33c,0x33f,0x339,0x342,0x33c,0x342,0x33c,0x342,0x33c,
+0x33f,0x339,0x342,0x33c,0x9e4,0x9de,0x342,0x33c,0x342,0x33c,0x342,0x33c,0x342,0x33c,0xd9e,0xd9b,
+0x342,0x33c,0xedf,0xedc,0xedf,0xedc,0xedf,0xedc,0xc06,0xc03,0xc06,0xc03,0xc06,0xc03,0xc06,0xc03,
+0xc06,0xc03,0xc06,0xc03,0xc06,0xc03,0xc06,0xc03,0xf0c,0xf09,0xf0c,0xf09,0xfff,0xffc,0xfff,0xffc,
+0xfff,0xffc,0xfff,0xffc,0xfff,0xffc,0xfff,0xffc,0xfff,0xffc,0xfff,0xffc,0x1164,0x1161,0x134a,0x1347,
+0x150f,0x150c,0x150f,0x150c,0x150f,0x150c,0x150f,0x150c,0xc,0x354,0x354,0x354,0x354,0x354,0x354,0x354,
+0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,0x354,
+0x354,0x354,0x354,0xc,0xc,0x357,0x345,0x348,0x348,0x34b,0x348,0x345,0x1917,0x34e,0x34e,0x34e,
+0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,
+0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x34e,0x351,
+0x1917,0x89d,0x9e7,0xc,0xc,0x14d9,0x14d9,0x13f5,0xf,0x957,0x957,0x957,0x957,0x957,0x957,0x957,
+0x957,0x957,0x957,0x957,0x957,0x957,0x957,0x957,0x957,0x957,0xda1,0x957,0x957,0x957,0x957,0x957,
+0x957,0x957,0x957,0x957,0x957,0x957,0x957,0x957,0x35a,0x35a,0x35a,0x35a,0x35a,0x35a,0x35a,0x35a,
+0x35a,0x35a,0xee2,0x35a,0x35a,0x35a,0x366,0x35a,0x35d,0x35a,0x35a,0x369,0x95a,0xda4,0xda7,0xda4,
+0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,
+0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,0x36c,
+0x36c,0x36c,0x36c,0xf,0xf,0xf,0xf,0x191a,0x36c,0x36c,0x36c,0x363,0x360,0xf,0xf,0xf,
+0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xf,0xcb4,0xcb4,0xcb4,0xcb4,0x13f8,0x14dc,0xf8a,0xf8a,
+0xf8a,0xf87,0xf87,0xdad,0x8a3,0xcae,0xcab,0xcab,0xca2,0xca2,0xca2,0xca2,0xca2,0xca2,0xf84,0xf84,
+0xf84,0xf84,0xf84,0x8a0,0x14d3,0x12,0xdb0,0x8a6,0x1311,0x387,0x38a,0x38a,0x38a,0x38a,0x38a,0x387,
+0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0xf8d,0xf8d,0xf8d,0xf8d,0xf8d,0x8a9,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0xb37,0xb37,0xb37,0xca2,0xca8,
+0xca5,0xdaa,0xdaa,0xdaa,0xdaa,0xdaa,0xdaa,0x130e,0x939,0x939,0x939,0x939,0x939,0x939,0x939,0x939,
+0x939,0x939,0x381,0x37e,0x37b,0x378,0xb9a,0xb9a,0x91b,0x387,0x387,0x393,0x387,0x38d,0x38d,0x38d,
+0x38d,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x9ed,0x9ed,0x387,0x387,
+0x387,0x387,0x387,0x9ed,0x38a,0x387,0x38a,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
+0x387,0x387,0x387,0x9ed,0x387,0x387,0x387,0x38a,0x93c,0x387,0x372,0x372,0x372,0x372,0x372,0x372,
+0x372,0x36f,0x378,0x375,0x375,0x372,0x372,0x372,0x372,0x390,0x390,0x372,0x372,0x378,0x375,0x375,
+0x375,0x372,0xcb1,0xcb1,0x384,0x384,0x384,0x384,0x384,0x384,0x384,0x384,0x384,0x384,0x9ed,0x9ed,
+0x9ed,0x9ea,0x9ea,0xcb1,0xa02,0xa02,0xa02,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9f9,
+0x9fc,0x9f9,0x15,0xa05,0x9ff,0x9f0,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,
+0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,0x9ff,
+0x9ff,0xcb7,0xcb7,0xcb7,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,0x9f6,
+0x9f6,0x9f6,0x9f6,0x9f6,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x9f3,0x15,
+0x15,0xcb7,0xcb7,0xcb7,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,
+0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,
+0xe10,0xe10,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,0x1011,
+0x1011,0x1011,0x1011,0x1011,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,
+0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,
+0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa0b,0xa08,0xa08,0xa08,0xa08,0xa08,0xa08,
+0xa08,0xa08,0xa08,0xa08,0xa08,0xb9d,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+0x18,0x18,0x18,0x18,0xf24,0xf24,0xf24,0xf24,0xf24,0xf24,0xf24,0xf24,0xf24,0xf24,0xf27,0xf27,
+0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,
+0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf27,0xf1b,
+0xf1b,0xf1b,0xf1b,0xf1b,0xf1b,0xf1b,0xf1b,0xf1b,0xf2a,0xf2a,0xf1e,0xf1e,0xf21,0xf30,0xf2d,0x10e,
+0x10e,0x193e,0x1941,0x1941,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x25b,
+0x25b,0x25b,0x25b,0x25b,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xb13,0xb13,0xb16,0xb16,0xb13,0xb13,0xb13,0xb13,0xb13,0xb13,0xb13,0xb13,
+0x72,0x72,0x72,0x72,0x1593,0x1593,0x1593,0x1593,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,
+0x1c2,0x1c2,0x1c2,0x1590,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1f5,0x1f5,0x1f5,0x1f5,0x1f5,0x1f5,0x1f5,0x164d,0x164d,0x164d,0x164d,0x164d,
+0x164d,0x164d,0x164d,0x164d,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x201,0x201,0x201,0x201,0x201,0x201,0x201,0x201,0x201,0x1686,0x1686,0x1686,
+0x1686,0x1686,0x1686,0x1686,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x177,0x177,0x177,
+0x177,0x177,0x177,0x177,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,
+0x27f,0x27f,0x27f,0x27f,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,
+0x1d7,0x1d7,0x1d7,0x1d7,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x14af,0x14af,0x14af,0x14af,0x14af,0x14af,0x14af,0x14af,0x14af,0x14af,0x1bc,0x1bc,
+0x1bc,0x1bc,0x1bc,0x1bc,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,
+0x264,0x264,0x264,0x264,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x18c0,0x18c3,0x18c3,0x258,0x258,0x258,0x258,0x258,0x258,0x258,0x258,0x258,
+0x258,0x258,0x258,0x258,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x198c,0x198c,0x198c,0x198c,0x198c,0x198c,0x198c,0x198c,0x198c,0x198c,0x26a,0x26a,
+0x26a,0x26a,0x26a,0x26a,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1782,0x1782,0x1782,0x1782,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,
+0x21c,0x21c,0x21c,0x21c,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,
+0x127b,0x127b,0x127b,0x180,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1638,0x1638,0x1638,0x1638,0x1638,0x1638,0x1638,0x1638,0x1638,0x1638,0x1ef,0x1ef,
+0x1ef,0x1ef,0x163e,0x163e,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,
+0x158a,0x158a,0x158a,0x158a,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,
+0x1674,0x1674,0x1674,0x1674,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,
+0x24f,0x24f,0x24f,0x24f,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,
+0x1911,0x1911,0x1911,0x1911,0x16ec,0x16ec,0x16ec,0x16ec,0x204,0x204,0x204,0x204,0x204,0x204,0x204,0x204,
+0x204,0x204,0x204,0x204,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0xe07,0xe07,0xe04,0xe04,0xe04,0xe07,0xdb,0xdb,0xdb,0xdb,0xdb,0xdb,
+0xdb,0xdb,0xdb,0xdb,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x22b,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,
+0x179a,0x179a,0x179a,0x179a,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x181b,0x181b,0x237,0x181b,0x181b,0x237,0x181b,0x181b,0x181b,0x181b,0x181b,0x237,
+0x237,0x237,0x237,0x237,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0x270,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,
+0x19a1,0x19a1,0x19a1,0x19a1,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x933,0x933,
+0,0,0x954,0x954,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,0x196e,
+0x196e,0x196e,0x261,0x261,3,3,3,3,3,3,3,3,3,3,3,3,
 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
-3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
-3,3,0x933,0x933,6,6,6,6,6,6,6,6,6,6,6,6,
+3,3,3,3,3,3,0x954,0x954,6,6,6,6,6,6,6,6,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,
-0xd35,0xd35,0xd35,0xd35,6,6,6,6,6,6,6,6,6,6,6,6,
-6,6,6,6,0x14b2,0x38d,0x39c,0x39c,0x1b,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,
-0x3a2,0x1b,0x1b,0x3a2,0x3a2,0x1b,0x1b,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,
-0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x1b,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x3a2,0x1b,0x3a2,0x1b,
-0x1b,0x1b,0x3a2,0x3a2,0x3a2,0x3a2,0x1b,0x1b,0x390,0xc90,0x38d,0x39c,0x39c,0x38d,0x38d,0x38d,
-0x38d,0x1b,0x1b,0x39c,0x39c,0x1b,0x1b,0x39f,0x39f,0x393,0xd83,0x1b,0x1b,0x1b,0x1b,0x1b,
-0x1b,0x1b,0x1b,0x38d,0x1b,0x1b,0x1b,0x1b,0x3a5,0x3a5,0x1b,0x3a5,0x3a2,0x3a2,0x38d,0x38d,
-0x1b,0x1b,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x91e,0x3a2,0x3a2,0x399,0x399,
-0x396,0x396,0x396,0x396,0x396,0x399,0x396,0x110a,0x184b,0x1848,0x1b,0x1b,0x1e,0xc93,0x3a8,0xc96,
-0x1e,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x1e,0x1e,0x1e,0x1e,0x3b4,0x3b4,0x1e,0x1e,0x3b4,
-0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x1e,0x3b4,0x3b4,
-0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x1e,0x3b4,0x3b7,0x1e,0x3b4,0x3b7,0x1e,0x3b4,0x3b4,0x1e,0x1e,
-0x3ab,0x1e,0x3b1,0x3b1,0x3b1,0x3a8,0x3a8,0x1e,0x1e,0x1e,0x1e,0x3a8,0x3a8,0x1e,0x1e,0x3a8,
-0x3a8,0x3ae,0x1e,0x1e,0x1e,0xf66,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x3b7,0x3b7,0x3b7,
-0x3b4,0x1e,0x3b7,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x921,0x921,0x921,0x921,0x921,0x921,
-0x921,0x921,0x921,0x921,0x3a8,0x3a8,0x3b4,0x3b4,0x3b4,0xf66,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
-0x1e,0x1e,0x1e,0x1e,0x21,0x3ba,0x3ba,0x3c3,0x21,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,
-0xc9f,0x3c6,0x21,0x3c6,0x3c6,0x3c6,0x21,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,
-0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x21,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x21,0x3c6,0x3c6,
-0x21,0x3c6,0x3c6,0x3c6,0x3c6,0x3c6,0x21,0x21,0x3bd,0x3c6,0x3c3,0x3c3,0x3c3,0x3ba,0x3ba,0x3ba,
-0x3ba,0x3ba,0x21,0x3ba,0x3ba,0x3c3,0x21,0x3c3,0x3c3,0x3c0,0x21,0x21,0x3c6,0x21,0x21,0x21,
-0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x3c6,0xc9f,0xc99,0xc99,
-0x21,0x21,0x924,0x924,0x924,0x924,0x924,0x924,0x924,0x924,0x924,0x924,0x13c8,0xc9c,0x21,0x21,
-0x21,0x21,0x21,0x21,0x21,0x16ce,0x184e,0x184e,0x184e,0x1851,0x1851,0x1851,0x24,0x3c9,0x3d8,0x3d8,
-0x24,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x24,0x24,0x3de,0x3de,0x24,0x24,0x3de,
-0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x3de,0x24,0x3de,0x3de,
-0x3de,0x3de,0x3de,0x3de,0x3de,0x24,0x3de,0x3de,0x24,0xca2,0x3de,0x3de,0x3de,0x3de,0x24,0x24,
-0x3cc,0x3de,0x3c9,0x3c9,0x3d8,0x3c9,0x3c9,0x3c9,0xf69,0x24,0x24,0x3d8,0x3db,0x24,0x24,0x3db,
-0x3db,0x3cf,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x3c9,0x3c9,0x24,0x24,0x24,0x24,
-0x3e1,0x3e1,0x24,0x3de,0x3de,0x3de,0xf69,0xf69,0x24,0x24,0x3d5,0x3d5,0x3d5,0x3d5,0x3d5,0x3d5,
-0x3d5,0x3d5,0x3d5,0x3d5,0x3d2,0xca2,0x12e1,0x12e1,0x12e1,0x12e1,0x12e1,0x12e1,0x24,0x24,0x24,0x24,
-0x24,0x24,0x24,0x24,0x27,0x27,0x3e4,0x3f0,0x27,0x3f0,0x3f0,0x3f0,0x3f0,0x3f0,0x3f0,0x27,
-0x27,0x27,0x3f0,0x3f0,0x3f0,0x27,0x3f0,0x3f0,0x3f3,0x3f0,0x27,0x27,0x27,0x3f0,0x3f0,0x27,
-0x3f0,0x27,0x3f0,0x3f0,0x27,0x27,0x27,0x3f0,0x3f0,0x27,0x27,0x27,0x3f0,0x3f0,0x92d,0x27,
-0x27,0x27,0x3f0,0x3f0,0x3f0,0x3f0,0x3f0,0x3f0,0x3f0,0x92d,0xd86,0x3f0,0x3f0,0x3f0,0x27,0x27,
-0x27,0x27,0x3e4,0x3ea,0x3e4,0x3ea,0x3ea,0x27,0x27,0x27,0x3ea,0x3ea,0x3ea,0x27,0x3ed,0x3ed,
-0x3ed,0x3e7,0x27,0x27,0xf6c,0x27,0x27,0x27,0x27,0x27,0x27,0x3e4,0x27,0x27,0x27,0x27,
-0x27,0x27,0x27,0x27,0x27,0x27,0xea0,0x92a,0x92a,0x92a,0x92a,0x92a,0x92a,0x92a,0x92a,0x92a,
-0x927,0x927,0x927,0xca5,0xca5,0xca5,0xca5,0xca5,0xca5,0xca8,0xca5,0x27,0x27,0x27,0x27,0x27,
-0x14b5,0x402,0x402,0x402,0x2a,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x2a,0x405,0x405,
-0x405,0x2a,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,
-0x405,0x2a,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x405,0x14b8,0x405,0x405,0x405,
-0x405,0x405,0x2a,0x2a,0x2a,0xf75,0x3f6,0x3f6,0x3f6,0x402,0x402,0x402,0x402,0x2a,0x3f6,0x3f6,
-0x3f9,0x2a,0x3f6,0x3f6,0x3f6,0x3fc,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x3f6,0x3f6,0x2a,
-0xf75,0xf75,0x16d1,0x2a,0x2a,0x2a,0x2a,0x2a,0x405,0x405,0xf6f,0xf6f,0x2a,0x2a,0x3ff,0x3ff,
-0x3ff,0x3ff,0x3ff,0x3ff,0x3ff,0x3ff,0x3ff,0x3ff,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
-0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0x178e,0x14bb,0x411,0x411,0x2d,0x417,0x417,0x417,
-0x417,0x417,0x417,0x417,0x417,0x2d,0x417,0x417,0x417,0x2d,0x417,0x417,0x417,0x417,0x417,0x417,
-0x417,0x417,0x417,0x417,0x417,0x417,0x417,0x417,0x417,0x2d,0x417,0x417,0x417,0x417,0x417,0x417,
-0x417,0x417,0x417,0x417,0x2d,0x417,0x417,0x417,0x417,0x417,0x2d,0x2d,0xcab,0xcae,0x411,0x408,
-0x414,0x411,0x408,0x411,0x411,0x2d,0x408,0x414,0x414,0x2d,0x414,0x414,0x408,0x40b,0x2d,0x2d,
-0x2d,0x2d,0x2d,0x2d,0x2d,0x408,0x408,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x417,0x2d,
-0x417,0x417,0xeb8,0xeb8,0x2d,0x2d,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,
-0x2d,0xebb,0xebb,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,
-0x1854,0x14be,0x423,0x423,0x30,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x30,0x429,0x429,
-0x429,0x30,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,
-0x423,0x41a,0x41a,0x41a,0xf78,0x30,0x423,0x423,0x423,0x30,0x426,0x426,0x426,0x41d,0x12e7,0x1791,
-0x30,0x30,0x30,0x30,0x1794,0x1794,0x1794,0x41a,0x1791,0x1791,0x1791,0x1791,0x1791,0x1791,0x1791,0x16d4,
-0x429,0x429,0xf78,0xf78,0x30,0x30,0x420,0x420,0x420,0x420,0x420,0x420,0x420,0x420,0x420,0x420,
-0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0x1791,0x1791,0x1791,0xf7e,0xf81,0xf81,0xf81,0xf81,0xf81,0xf81,
-0x33,0x33,0x9f6,0x9f6,0x33,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,
-0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x33,0x33,0x33,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,
-0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x33,0x9fc,
-0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x9fc,0x33,0x9fc,0x33,0x33,0x9fc,0x9fc,0x9fc,0x9fc,
-0x9fc,0x9fc,0x9fc,0x33,0x33,0x33,0x9f0,0x33,0x33,0x33,0x33,0x9ed,0x9f6,0x9f6,0x9ed,0x9ed,
-0x9ed,0x33,0x9ed,0x33,0x9f6,0x9f6,0x9f9,0x9f6,0x9f9,0x9f9,0x9f9,0x9ed,0x33,0x33,0x33,0x33,
-0x33,0x33,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x14c1,0x33,0x33,0x9f6,0x9f6,
-0x9f3,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x36,0x444,0x444,0x444,
-0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,
-0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x444,0x42f,0x444,0x441,
-0x42f,0x42f,0x42f,0x42f,0x42f,0x42f,0x435,0x36,0x36,0x36,0x36,0x42c,0x44a,0x44a,0x44a,0x44a,
-0x44a,0x444,0x447,0x432,0x432,0x432,0x432,0x432,0x432,0x42f,0x432,0x438,0x43e,0x43e,0x43e,0x43e,
-0x43e,0x43e,0x43e,0x43e,0x43e,0x43e,0x43b,0x43b,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
+6,6,6,6,6,6,6,6,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,
+0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,6,6,6,6,6,6,6,6,
+6,6,6,6,6,6,6,6,0x14e2,0x3ab,0x3ba,0x3ba,0x1b,0x3c0,0x3c0,0x3c0,
+0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x1b,0x1b,0x3c0,0x3c0,0x1b,0x1b,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,
+0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x1b,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,0x3c0,
+0x3c0,0x1b,0x3c0,0x1b,0x1b,0x1b,0x3c0,0x3c0,0x3c0,0x3c0,0x1b,0x1b,0x3ae,0xcbd,0x3ab,0x3ba,
+0x3ba,0x3ab,0x3ab,0x3ab,0x3ab,0x1b,0x1b,0x3ba,0x3ba,0x1b,0x1b,0x3bd,0x3bd,0x3b1,0xdb6,0x1b,
+0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x1b,0x3ab,0x1b,0x1b,0x1b,0x1b,0x3c3,0x3c3,0x1b,0x3c3,
+0x3c0,0x3c0,0x3ab,0x3ab,0x1b,0x1b,0x942,0x942,0x942,0x942,0x942,0x942,0x942,0x942,0x942,0x942,
+0x3c0,0x3c0,0x3b7,0x3b7,0x3b4,0x3b4,0x3b4,0x3b4,0x3b4,0x3b7,0x3b4,0x113a,0x187b,0x1878,0x191d,0x1b,
+0x1e,0xcc0,0x3c6,0xcc3,0x1e,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x1e,0x1e,0x1e,0x1e,0x3d2,
+0x3d2,0x1e,0x1e,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,
+0x3d2,0x1e,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x3d2,0x1e,0x3d2,0x3d5,0x1e,0x3d2,0x3d5,0x1e,
+0x3d2,0x3d2,0x1e,0x1e,0x3c9,0x1e,0x3cf,0x3cf,0x3cf,0x3c6,0x3c6,0x1e,0x1e,0x1e,0x1e,0x3c6,
+0x3c6,0x1e,0x1e,0x3c6,0x3c6,0x3cc,0x1e,0x1e,0x1e,0xf96,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
+0x1e,0x3d5,0x3d5,0x3d5,0x3d2,0x1e,0x3d5,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x945,0x945,
+0x945,0x945,0x945,0x945,0x945,0x945,0x945,0x945,0x3c6,0x3c6,0x3d2,0x3d2,0x3d2,0xf96,0x1920,0x1e,
+0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x21,0x3d8,0x3d8,0x3e1,0x21,0x3e4,0x3e4,0x3e4,
+0x3e4,0x3e4,0x3e4,0x3e4,0xccc,0x3e4,0x21,0x3e4,0x3e4,0x3e4,0x21,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,
+0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x21,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,
+0x3e4,0x21,0x3e4,0x3e4,0x21,0x3e4,0x3e4,0x3e4,0x3e4,0x3e4,0x21,0x21,0x3db,0x3e4,0x3e1,0x3e1,
+0x3e1,0x3d8,0x3d8,0x3d8,0x3d8,0x3d8,0x21,0x3d8,0x3d8,0x3e1,0x21,0x3e1,0x3e1,0x3de,0x21,0x21,
+0x3e4,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21,
+0x3e4,0xccc,0xcc6,0xcc6,0x21,0x21,0x948,0x948,0x948,0x948,0x948,0x948,0x948,0x948,0x948,0x948,
+0x13fb,0xcc9,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x16fe,0x187e,0x187e,0x187e,0x1881,0x1881,0x1881,
+0x24,0x3e7,0x3f6,0x3f6,0x24,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x24,0x24,0x3fc,
+0x3fc,0x24,0x24,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,
+0x3fc,0x24,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x3fc,0x24,0x3fc,0x3fc,0x24,0xccf,0x3fc,0x3fc,
+0x3fc,0x3fc,0x24,0x24,0x3ea,0x3fc,0x3e7,0x3e7,0x3f6,0x3e7,0x3e7,0x3e7,0xf99,0x24,0x24,0x3f6,
+0x3f9,0x24,0x24,0x3f9,0x3f9,0x3ed,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x3e7,0x3e7,
+0x24,0x24,0x24,0x24,0x3ff,0x3ff,0x24,0x3fc,0x3fc,0x3fc,0xf99,0xf99,0x24,0x24,0x3f3,0x3f3,
+0x3f3,0x3f3,0x3f3,0x3f3,0x3f3,0x3f3,0x3f3,0x3f3,0x3f0,0xccf,0x131d,0x131d,0x131d,0x131d,0x131d,0x131d,
+0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x27,0x27,0x402,0x40e,0x27,0x40e,0x40e,0x40e,
+0x40e,0x40e,0x40e,0x27,0x27,0x27,0x40e,0x40e,0x40e,0x27,0x40e,0x40e,0x411,0x40e,0x27,0x27,
+0x27,0x40e,0x40e,0x27,0x40e,0x27,0x40e,0x40e,0x27,0x27,0x27,0x40e,0x40e,0x27,0x27,0x27,
+0x40e,0x40e,0x40e,0x27,0x27,0x27,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0x40e,0xdb9,0x40e,
+0x40e,0x40e,0x27,0x27,0x27,0x27,0x402,0x408,0x402,0x408,0x408,0x27,0x27,0x27,0x408,0x408,
+0x408,0x27,0x40b,0x40b,0x40b,0x405,0x27,0x27,0xf9c,0x27,0x27,0x27,0x27,0x27,0x27,0x402,
+0x27,0x27,0x27,0x27,0x27,0x27,0x27,0x27,0x27,0x27,0xed0,0x94e,0x94e,0x94e,0x94e,0x94e,
+0x94e,0x94e,0x94e,0x94e,0x94b,0x94b,0x94b,0xd89,0xcd2,0xcd2,0xcd2,0xcd2,0xcd2,0xcd5,0xcd2,0x27,
+0x27,0x27,0x27,0x27,0x14e5,0x420,0x420,0x420,0x1923,0x423,0x423,0x423,0x423,0x423,0x423,0x423,
+0x423,0x2a,0x423,0x423,0x423,0x2a,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,
+0x423,0x423,0x423,0x423,0x423,0x2a,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,0x423,
+0x14e8,0x423,0x423,0x423,0x423,0x423,0x2a,0x2a,0x2a,0xfa5,0x414,0x414,0x414,0x420,0x420,0x420,
+0x420,0x2a,0x414,0x414,0x417,0x2a,0x414,0x414,0x414,0x41a,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,
+0x2a,0x414,0x414,0x2a,0xfa5,0xfa5,0x1701,0x2a,0x2a,0x2a,0x2a,0x2a,0x423,0x423,0xf9f,0xf9f,
+0x2a,0x2a,0x41d,0x41d,0x41d,0x41d,0x41d,0x41d,0x41d,0x41d,0x41d,0x41d,0x2a,0x2a,0x2a,0x2a,
+0x2a,0x2a,0x2a,0x2a,0xfa2,0xfa2,0xfa2,0xfa2,0xfa2,0xfa2,0xfa2,0xfa2,0x17be,0x14eb,0x42f,0x42f,
+0x1926,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x2d,0x435,0x435,0x435,0x2d,0x435,0x435,
+0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x2d,0x435,0x435,
+0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x435,0x2d,0x435,0x435,0x435,0x435,0x435,0x2d,0x2d,
+0xcd8,0xcdb,0x42f,0x426,0x432,0x42f,0x426,0x42f,0x42f,0x2d,0x426,0x432,0x432,0x2d,0x432,0x432,
+0x426,0x429,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x426,0x426,0x2d,0x2d,0x2d,0x2d,0x2d,
+0x2d,0x2d,0x435,0x2d,0x435,0x435,0xee8,0xee8,0x2d,0x2d,0x42c,0x42c,0x42c,0x42c,0x42c,0x42c,
+0x42c,0x42c,0x42c,0x42c,0x2d,0xeeb,0xeeb,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,0x2d,
+0x2d,0x2d,0x2d,0x2d,0x1884,0x14ee,0x441,0x441,0x30,0x447,0x447,0x447,0x447,0x447,0x447,0x447,
+0x447,0x30,0x447,0x447,0x447,0x30,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,
+0x447,0x447,0x447,0x447,0x441,0x438,0x438,0x438,0xfa8,0x30,0x441,0x441,0x441,0x30,0x444,0x444,
+0x444,0x43b,0x1323,0x17c1,0x30,0x30,0x30,0x30,0x17c4,0x17c4,0x17c4,0x438,0x17c1,0x17c1,0x17c1,0x17c1,
+0x17c1,0x17c1,0x17c1,0x1704,0x447,0x447,0xfa8,0xfa8,0x30,0x30,0x43e,0x43e,0x43e,0x43e,0x43e,0x43e,
+0x43e,0x43e,0x43e,0x43e,0xfab,0xfab,0xfab,0xfab,0xfab,0xfab,0x17c1,0x17c1,0x17c1,0xfae,0xfb1,0xfb1,
+0xfb1,0xfb1,0xfb1,0xfb1,0x33,0x33,0xa17,0xa17,0x33,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,
+0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0x33,0x33,0x33,0xa1d,0xa1d,
+0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,
+0xa1d,0xa1d,0x33,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0x33,0xa1d,0x33,0x33,
+0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0xa1d,0x33,0x33,0x33,0xa11,0x33,0x33,0x33,0x33,0xa0e,
+0xa17,0xa17,0xa0e,0xa0e,0xa0e,0x33,0xa0e,0x33,0xa17,0xa17,0xa1a,0xa17,0xa1a,0xa1a,0xa1a,0xa0e,
+0x33,0x33,0x33,0x33,0x33,0x33,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,0x14f1,
+0x33,0x33,0xa17,0xa17,0xa14,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,
+0x36,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,
+0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,0x462,
+0x462,0x44d,0x462,0x45f,0x44d,0x44d,0x44d,0x44d,0x44d,0x44d,0x453,0x36,0x36,0x36,0x36,0x44a,
+0x468,0x468,0x468,0x468,0x468,0x462,0x465,0x450,0x450,0x450,0x450,0x450,0x450,0x44d,0x450,0x456,
+0x45c,0x45c,0x45c,0x45c,0x45c,0x45c,0x45c,0x45c,0x45c,0x45c,0x459,0x459,0x36,0x36,0x36,0x36,
 0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,
-0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x39,0x459,0x459,0x39,0x459,0x39,0x39,0x459,
-0x459,0x39,0x459,0x39,0x39,0x459,0x39,0x39,0x39,0x39,0x39,0x39,0x459,0x459,0x459,0x459,
-0x39,0x459,0x459,0x459,0x459,0x459,0x459,0x459,0x39,0x459,0x459,0x459,0x39,0x459,0x39,0x459,
-0x39,0x39,0x459,0x459,0x39,0x459,0x459,0x459,0x459,0x44d,0x459,0x456,0x44d,0x44d,0x44d,0x44d,
-0x44d,0x44d,0x39,0x44d,0x44d,0x459,0x39,0x39,0x462,0x462,0x462,0x462,0x462,0x39,0x45f,0x39,
-0x450,0x450,0x450,0x450,0x450,0x44d,0x39,0x39,0x453,0x453,0x453,0x453,0x453,0x453,0x453,0x453,
-0x453,0x453,0x39,0x39,0x45c,0x45c,0x13cb,0x13cb,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,
+0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x39,0x477,0x477,0x39,
+0x477,0x39,0x39,0x477,0x477,0x39,0x477,0x39,0x39,0x477,0x39,0x39,0x39,0x39,0x39,0x39,
+0x477,0x477,0x477,0x477,0x39,0x477,0x477,0x477,0x477,0x477,0x477,0x477,0x39,0x477,0x477,0x477,
+0x39,0x477,0x39,0x477,0x39,0x39,0x477,0x477,0x39,0x477,0x477,0x477,0x477,0x46b,0x477,0x474,
+0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x39,0x46b,0x46b,0x477,0x39,0x39,0x480,0x480,0x480,0x480,
+0x480,0x39,0x47d,0x39,0x46e,0x46e,0x46e,0x46e,0x46e,0x46b,0x39,0x39,0x471,0x471,0x471,0x471,
+0x471,0x471,0x471,0x471,0x471,0x471,0x39,0x39,0x47a,0x47a,0x13fe,0x13fe,0x39,0x39,0x39,0x39,
 0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,
-0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x96f,0x96f,0x96f,0x972,0x96f,0x96f,0x96f,0x96f,
-0x3c,0x96f,0x96f,0x96f,0x96f,0x972,0x96f,0x96f,0x96f,0x96f,0x972,0x96f,0x96f,0x96f,0x96f,0x972,
-0x96f,0x96f,0x96f,0x96f,0x972,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,0x96f,
-0x96f,0x972,0xa0b,0xf8d,0xf8d,0x3c,0x3c,0x3c,0x3c,0x93c,0x93c,0x93f,0x93c,0x93f,0x93f,0x948,
-0x93f,0x948,0x93c,0x93c,0x93c,0x93c,0x93c,0x969,0x93c,0x93f,0x942,0x942,0x945,0x94e,0x942,0x942,
-0x96f,0x96f,0x96f,0x96f,0x12f0,0x12ea,0x12ea,0x12ea,0x93c,0x93c,0x93c,0x93f,0x93c,0x93c,0x9ff,0x93c,
-0x3c,0x93c,0x93c,0x93c,0x93c,0x93f,0x93c,0x93c,0x93c,0x93c,0x93f,0x93c,0x93c,0x93c,0x93c,0x93f,
-0x93c,0x93c,0x93c,0x93c,0x93f,0x93c,0x9ff,0x9ff,0x9ff,0x93c,0x93c,0x93c,0x93c,0x93c,0x93c,0x93c,
-0x9ff,0x93f,0x9ff,0x9ff,0x9ff,0x3c,0xa08,0xa08,0xa05,0xa05,0xa05,0xa05,0xa05,0xa05,0xa02,0xa05,
-0xa05,0xa05,0xa05,0xa05,0xa05,0x3c,0xf84,0xa05,0xd89,0xd89,0xf87,0xf8a,0xf84,0x110d,0x110d,0x110d,
-0x110d,0x12ed,0x12ed,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
+0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x39,0x990,0x990,0x990,0x993,
+0x990,0x990,0x990,0x990,0x3c,0x990,0x990,0x990,0x990,0x993,0x990,0x990,0x990,0x990,0x993,0x990,
+0x990,0x990,0x990,0x993,0x990,0x990,0x990,0x990,0x993,0x990,0x990,0x990,0x990,0x990,0x990,0x990,
+0x990,0x990,0x990,0x990,0x990,0x993,0xa2c,0xfbd,0xfbd,0x3c,0x3c,0x3c,0x3c,0x95d,0x95d,0x960,
+0x95d,0x960,0x960,0x969,0x960,0x969,0x95d,0x95d,0x95d,0x95d,0x95d,0x98a,0x95d,0x960,0x963,0x963,
+0x966,0x96f,0x963,0x963,0x990,0x990,0x990,0x990,0x132c,0x1326,0x1326,0x1326,0x95d,0x95d,0x95d,0x960,
+0x95d,0x95d,0xa20,0x95d,0x3c,0x95d,0x95d,0x95d,0x95d,0x960,0x95d,0x95d,0x95d,0x95d,0x960,0x95d,
+0x95d,0x95d,0x95d,0x960,0x95d,0x95d,0x95d,0x95d,0x960,0x95d,0xa20,0xa20,0xa20,0x95d,0x95d,0x95d,
+0x95d,0x95d,0x95d,0x95d,0xa20,0x960,0xa20,0xa20,0xa20,0x3c,0xa29,0xa29,0xa26,0xa26,0xa26,0xa26,
+0xa26,0xa26,0xa23,0xa26,0xa26,0xa26,0xa26,0xa26,0xa26,0x3c,0xfb4,0xa26,0xdbc,0xdbc,0xfb7,0xfba,
+0xfb4,0x113d,0x113d,0x113d,0x113d,0x1329,0x1329,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
 0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
-0x3c,0x3c,0x3c,0x3c,0x468,0x468,0x468,0x468,0x468,0x468,0x3f,0x13d1,0x3f,0x3f,0x3f,0x3f,
-0x3f,0x13d1,0x3f,0x3f,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,
-0x465,0x465,0x465,0x465,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,0xa35,0x42,0xa35,0xa35,
-0xa35,0xa35,0x42,0x42,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0x42,0xa35,0x42,0xa35,0xa35,
-0xa35,0xa35,0x42,0x42,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,0xa35,0x42,0xa35,0xa35,
-0xa35,0xa35,0x42,0x42,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,0xa35,0x42,0xa35,0xa35,0xa35,0xa35,0x42,0x42,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0x42,0xa35,0x42,0xa35,0xa35,0xa35,0xa35,0x42,0x42,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0x42,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,
-0xa35,0x42,0xa35,0xa35,0xa35,0xa35,0x42,0x42,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0x42,0x42,0x12f3,0x12f3,0xd92,0xd95,0xa2f,0xa38,0xa2c,0xa2c,0xa2c,0xa2c,0xa38,
-0xa38,0xa32,0xa32,0xa32,0xa32,0xa32,0xa32,0xa32,0xa32,0xa32,0xa29,0xa29,0xa29,0xa29,0xa29,0xa29,
-0xa29,0xa29,0xa29,0xa29,0xa29,0x42,0x42,0x42,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,
-0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0x16da,0x45,0x45,
-0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x45,0x45,0xa4d,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,
-0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,0xa50,
-0xa50,0xa50,0xa50,0xa4a,0xa47,0x48,0x48,0x48,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
-0xa56,0xa56,0xa56,0xa53,0xa53,0xa53,0xa56,0xa56,0xa56,0x14c4,0x14c4,0x14c4,0x14c4,0x14c4,0x14c4,0x14c4,
-0x14c4,0x4b,0x4b,0x4b,0x4b,0x4b,0x4b,0x4b,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa59,0xa77,
-0xa77,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5f,0xa5c,0xa6e,0xa6e,0xa71,0xa7a,
-0xa68,0xa65,0xa6e,0xa6b,0xa7a,0xcb1,0x4e,0x4e,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,0xa74,
-0xa74,0xa74,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0xcb4,0xcb4,0xcb4,0xcb4,0xcb4,0xcb4,0xcb4,0xcb4,
-0xcb4,0xcb4,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0xa89,0xa89,0xb07,0xb0a,0xa8f,0xb04,0xa8c,0xa89,
-0xa92,0xaa1,0xa95,0xaa4,0xaa4,0xaa4,0xa80,0x51,0xa98,0xa98,0xa98,0xa98,0xa98,0xa98,0xa98,0xa98,
-0xa98,0xa98,0x51,0x51,0x51,0x51,0x51,0x51,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
-0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
-0x51,0x51,0x51,0x51,0x51,0x51,0x51,0x51,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
-0xa9b,0xa83,0xfae,0x51,0x51,0x51,0x51,0x51,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,
-0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x486,0x486,0x486,0x486,0x486,0x486,0x54,0x54,
-0x489,0x489,0x489,0x489,0x489,0x489,0x54,0x54,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x54,0x489,0x54,0x489,0x54,0x489,0x54,0x489,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x486,0x486,0x486,0x486,0x486,0x486,0x54,0x54,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x486,0x486,0x486,0x486,0x486,0x54,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x480,0x486,0x480,0x480,0x47d,0x486,0x486,0x486,0x54,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x47d,0x47d,0x47d,0x486,0x486,0x486,0x486,0x54,0x54,0x486,0x486,
-0x489,0x489,0x489,0x489,0x54,0x47d,0x47d,0x47d,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x47d,0x47d,0x47d,0x54,0x54,0x486,0x486,0x486,0x54,0x486,0x486,
-0x489,0x489,0x489,0x489,0x489,0x483,0x480,0x54,0xb7c,0xb7f,0xb7f,0xb7f,0xfb7,0x57,0x14a0,0x14a0,
-0x14a0,0x14a0,0x492,0x492,0x492,0x492,0x492,0x492,0x4dd,0xb91,0x5a,0x5a,0x699,0x4dd,0x4dd,0x4dd,
-0x4dd,0x4dd,0x4e3,0x4f5,0x4e3,0x4ef,0x4e9,0x69c,0x4da,0x696,0x696,0x696,0x696,0x4da,0x4da,0x4da,
-0x4da,0x4da,0x4e0,0x4f2,0x4e0,0x4ec,0x4e6,0x5a,0xda1,0xda1,0xda1,0xda1,0xda1,0x12f6,0x12f6,0x12f6,
-0x12f6,0x12f6,0x12f6,0x12f6,0x12f6,0x5a,0x5a,0x5a,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,
-0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x504,0x504,0x504,0x504,0x504,0x504,0x504,0x504,
-0x504,0x504,0x504,0x504,0x504,0x501,0x501,0x501,0x501,0x504,0xab6,0xab6,0xb97,0xb9d,0xb9d,0xb9a,
-0xb9a,0xb9a,0xb9a,0xda7,0xebe,0xebe,0xebe,0xebe,0x10f8,0x60,0x60,0x60,0x60,0x60,0x60,0x60,
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x534,0x534,0x534,0xabf,0xec7,0xfbd,0xfbd,0xfbd,
-0xfbd,0x1254,0x16e0,0x16e0,0x63,0x63,0x63,0x63,0x6c3,0x6c3,0x6c3,0x6c3,0x6c6,0x6c6,0x6c6,0x6c6,
-0x6c6,0x6c6,0x540,0x540,0x53d,0x53d,0x53d,0x53d,0x567,0x567,0x567,0x567,0x567,0xac8,0xac8,0x66,
-0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,
-0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x56a,0x56a,0x56a,0x56a,0x56a,0x56a,0x56a,0x56a,
-0x56a,0x56a,0x56a,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
-0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,
-0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,
-0xae3,0xae3,0x6c,0xae3,0xae3,0xae3,0xae3,0xae6,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,
-0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae6,0x6c,0x6c,0x6c,0x6c,
-0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,
-0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0x6f,0x6f,
-0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x75,0x7fb,0x7f5,0x7fb,0x7f5,0x7fb,0x7f5,0x7fb,
-0x7f5,0x7fb,0x7f5,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,
-0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f5,0x7f5,0x7f5,0x7fb,0x7f5,0x7fb,0x7f5,0x7fb,
-0x7f5,0x7f5,0x7f5,0x7f5,0x7f5,0x7f5,0x7fb,0x7f5,0x7f5,0x7f5,0x7f5,0x7f5,0x7f8,0xc3f,0xc3f,0x75,
-0x75,0x90f,0x90f,0x8d9,0x8d9,0x7fe,0x801,0xc3c,0x78,0x78,0x78,0x78,0x78,0x813,0x813,0x813,
-0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,
-0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x813,0x10e6,0x18c3,0x78,0x7b,0x816,0x816,0x816,
-0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x7b,
-0x8e2,0x8e2,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,0x8e5,
-0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,
-0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0xaf5,0x1389,0x1389,0x1389,0x7e,0x7e,0x7e,0x7e,0x7e,
-0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,
-0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0x81f,0xd41,0xd41,0x81,
-0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,
-0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x81,
-0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0x84,0x84,0x84,
-0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,
-0xb01,0xc48,0xb01,0xb01,0xb01,0xc48,0xb01,0x87,0x87,0x87,0x87,0x87,0x87,0x87,0x87,0x87,
-0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,
-0x993,0x993,0x993,0x993,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,
-0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,
-0x5c4,0x5c4,0x5c4,0x5c4,0x5c4,0x5c4,0x5c4,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,
-0x8d,0x8d,0x8d,0x5b2,0x5b2,0x5b2,0x5b2,0x5b2,0x8d,0x8d,0x8d,0x8d,0x8d,0xad4,0x5b5,0x5bb,
-0x5c1,0x5c1,0x5c1,0x5c1,0x5c1,0x5c1,0x5c1,0x5c1,0x5c1,0x5b8,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,
-0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x8d,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x8d,0x5bb,0x8d,
-0x5bb,0x5bb,0x8d,0x5bb,0x5bb,0x8d,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5bb,0x5be,
-0x5d6,0x5d0,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,
-0x1308,0x1308,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
-0x90,0x90,0x90,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d6,0x5d0,
-0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
-0x5d3,0x5d0,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d0,0x5d3,0x5d0,0x5d0,0x5d3,0x5d3,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d3,0x5d0,0x5d0,0x5d3,0x5d0,0x5d3,0x5d3,0x5d3,0x5d0,0x5d3,0x5d3,0x5d3,0x5d3,
-0x90,0x90,0x5d3,0x5d3,0x5d3,0x5d3,0x5d0,0x5d0,0x5d3,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d3,0x5d3,0x5d3,0x5d0,0x5d0,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
-0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,
-0x5d6,0x5d6,0x930,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5cd,0x5cd,0xbd3,0xd59,0x90,0x90,
-0x837,0x849,0x846,0x849,0x846,0xc5d,0xc5d,0xd4d,0xd4a,0x83a,0x83a,0x83a,0x83a,0x84c,0x84c,0x84c,
-0x864,0x867,0x876,0x93,0x86a,0x86d,0x879,0x879,0x861,0x858,0x852,0x858,0x852,0x858,0x852,0x855,
-0x855,0x870,0x870,0x873,0x870,0x870,0x870,0x93,0x870,0x85e,0x85b,0x855,0x93,0x93,0x93,0x93,
-0x5e2,0x5ee,0x5e2,0xbd6,0x5e2,0x96,0x5e2,0x5ee,0x5e2,0x5ee,0x5e2,0x5ee,0x5e2,0x5ee,0x5e2,0x5ee,
-0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5eb,
-0x5e5,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x96,0x96,0x5df,
-0x735,0x738,0x74d,0x750,0x72f,0x738,0x738,0x9c,0x717,0x71a,0x71a,0x71a,0x71a,0x717,0x717,0x9c,
-0x99,0x99,0x99,0x99,0x99,0x99,0x99,0x99,0x99,0xad7,0xad7,0xad7,0x996,0x711,0x5f1,0x5f1,
-0x9c,0x75f,0x73e,0x72f,0x738,0x735,0x72f,0x741,0x732,0x72c,0x72f,0x74d,0x744,0x73b,0x75c,0x72f,
-0x759,0x759,0x759,0x759,0x759,0x759,0x759,0x759,0x759,0x759,0x74a,0x747,0x74d,0x74d,0x74d,0x75f,
-0x720,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,
-0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x9c,
-0x9c,0x9c,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x9c,0x9c,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,
-0x9c,0x9c,0x71d,0x71d,0x71d,0x71d,0x71d,0x71d,0x9c,0x9c,0x71d,0x71d,0x71d,0x9c,0x9c,0x9c,
-0xb1f,0xb1f,0xb1f,0xb1f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x1860,0x1860,0x1860,
-0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,0xb25,
-0xb25,0xb25,0xb25,0xa2,0xa2,0xa2,0xa2,0xa2,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,
-0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,
-0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xa5,0xa5,
-0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xa8,
-0xa8,0xfc9,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0x16e6,0x16e6,0x16e6,0x16e6,0x16e6,0x16e6,0x16e6,0x16e6,
-0x16e6,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,
-0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xab,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xab,0xb52,0xb52,0xab,0xab,0xb52,0xab,0xab,0xb52,0xb52,0xab,
-0xab,0xb52,0xb52,0xb52,0xb52,0xab,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,
-0xb4f,0xb4f,0xab,0xb4f,0xab,0xb4f,0xb4f,0xb4f,0xb4f,0xcd2,0xb4f,0xb4f,0xab,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,0xab,0xb52,
-0xb52,0xb52,0xb52,0xab,0xab,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xab,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xab,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb52,0xb52,0xab,0xb52,0xb52,0xb52,0xb52,0xab,0xb52,0xb52,0xb52,0xb52,0xb52,0xab,0xb52,0xab,
-0xab,0xab,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xab,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xdbf,0xdbf,0xab,0xab,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb49,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xed6,0xed3,
-0xab,0xab,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,
-0xb4c,0xb4c,0xb4c,0xb4c,0xae,0xb58,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,
+0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x486,0x486,0x486,0x486,0x486,0x486,0x3f,0x1404,
+0x3f,0x3f,0x3f,0x3f,0x3f,0x1404,0x3f,0x3f,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,
+0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,
+0xa56,0x42,0xa56,0xa56,0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0x42,
+0xa56,0x42,0xa56,0xa56,0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,
+0xa56,0x42,0xa56,0xa56,0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,0xa56,0x42,0xa56,0xa56,
+0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0x42,0xa56,0x42,0xa56,0xa56,
+0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0x42,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xdcb,0xa56,0x42,0xa56,0xa56,0xa56,0xa56,0x42,0x42,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xdcb,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0x42,0x42,0x132f,0x132f,0xdc5,0xdc8,0xa50,0xa59,0xa4d,
+0xa4d,0xa4d,0xa4d,0xa59,0xa59,0xa53,0xa53,0xa53,0xa53,0xa53,0xa53,0xa53,0xa53,0xa53,0xa4a,0xa4a,
+0xa4a,0xa4a,0xa4a,0xa4a,0xa4a,0xa4a,0xa4a,0xa4a,0xa4a,0x42,0x42,0x42,0xa5c,0xa5c,0xa5c,0xa5c,
+0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,
+0xa5c,0x170a,0x45,0x45,0x1707,0x1707,0x1707,0x1707,0x1707,0x1707,0x45,0x45,0xa6e,0xa71,0xa71,0xa71,
+0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,
+0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa71,0xa6b,0xa68,0x48,0x48,0x48,0xa77,0xa77,0xa77,0xa77,
+0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa74,0xa74,0xa74,0xa77,0xa77,0xa77,0x14f4,0x14f4,0x14f4,
+0x14f4,0x14f4,0x14f4,0x14f4,0x14f4,0x4b,0x4b,0x4b,0x4b,0x4b,0x4b,0x4b,0xa98,0xa98,0xa98,0xa98,
+0xa98,0xa98,0xa7a,0xa98,0xa98,0xa7d,0xa7d,0xa7d,0xa7d,0xa7d,0xa7d,0xa7d,0xa7d,0xa7d,0xa80,0xa7d,
+0xa8f,0xa8f,0xa92,0xa9b,0xa89,0xa86,0xa8f,0xa8c,0xa9b,0xcde,0x4e,0x4e,0xa95,0xa95,0xa95,0xa95,
+0xa95,0xa95,0xa95,0xa95,0xa95,0xa95,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0xce1,0xce1,0xce1,0xce1,
+0xce1,0xce1,0xce1,0xce1,0xce1,0xce1,0x4e,0x4e,0x4e,0x4e,0x4e,0x4e,0xaaa,0xaaa,0xb2e,0xb31,
+0xab0,0xb2b,0xaad,0xaaa,0xab3,0xac2,0xab6,0xac5,0xac5,0xac5,0xaa1,0x51,0xab9,0xab9,0xab9,0xab9,
+0xab9,0xab9,0xab9,0xab9,0xab9,0xab9,0x51,0x51,0x51,0x51,0x51,0x51,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0x1929,0x51,0x51,0x51,0x51,0x51,0x51,0x51,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xaa4,0xfde,0x51,0x51,0x51,0x51,0x51,0x1194,0x1194,0x1194,0x1194,
+0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x54,0x54,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x54,0x54,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x54,0x4a7,0x54,0x4a7,0x54,0x4a7,0x54,0x4a7,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x54,0x54,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x54,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x49e,0x4a4,0x49e,0x49e,0x49b,0x4a4,0x4a4,
+0x4a4,0x54,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x49b,0x49b,0x49b,0x4a4,0x4a4,0x4a4,0x4a4,
+0x54,0x54,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x54,0x49b,0x49b,0x49b,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a4,0x4a4,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x49b,0x49b,0x49b,0x54,0x54,0x4a4,0x4a4,
+0x4a4,0x54,0x4a4,0x4a4,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a1,0x49e,0x54,0xba3,0xba6,0xba6,0xba6,
+0xfe7,0x57,0x14d0,0x14d0,0x14d0,0x14d0,0x4b0,0x4b0,0x4b0,0x4b0,0x4b0,0x4b0,0x4fb,0xbb8,0x5a,0x5a,
+0x6ba,0x4fb,0x4fb,0x4fb,0x4fb,0x4fb,0x501,0x513,0x501,0x50d,0x507,0x6bd,0x4f8,0x6b7,0x6b7,0x6b7,
+0x6b7,0x4f8,0x4f8,0x4f8,0x4f8,0x4f8,0x4fe,0x510,0x4fe,0x50a,0x504,0x5a,0xdd4,0xdd4,0xdd4,0xdd4,
+0xdd4,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x5a,0x5a,0x5a,0x5d,0x5d,0x5d,0x5d,
+0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x5d,0x522,0x522,0x522,0x522,
+0x522,0x522,0x522,0x522,0x522,0x522,0x522,0x522,0x522,0x51f,0x51f,0x51f,0x51f,0x522,0xad7,0xada,
+0xbbe,0xbc4,0xbc4,0xbc1,0xbc1,0xbc1,0xbc1,0xdda,0xeee,0xeee,0xeee,0xeee,0x1128,0x60,0x60,0x60,
+0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x552,0x552,0x552,0xae3,
+0xef7,0xfed,0xfed,0xfed,0xfed,0x1287,0x1710,0x1710,0x63,0x63,0x63,0x63,0x6e4,0x6e4,0x6e4,0x6e4,
+0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x55e,0x55e,0x55b,0x55b,0x55b,0x55b,0x585,0x585,0x585,0x585,
+0x585,0xaef,0xaef,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,
+0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x588,0x588,0x588,0x588,
+0x588,0x588,0x588,0x588,0x588,0x588,0x588,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0xb0a,0xb0a,0xb0a,0xb0a,
+0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,
+0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0x6c,0xb0a,0xb0a,0xb0a,0xb0a,0xb0d,0xb0a,0xb0a,0xb0a,0xb0a,
+0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0d,
+0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0xb10,0xb10,0xb10,0xb10,
+0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,
+0xb10,0xb10,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x6f,0x75,0x81c,0x816,0x81c,
+0x816,0x81c,0x816,0x81c,0x816,0x81c,0x816,0x816,0x819,0x816,0x819,0x816,0x819,0x816,0x819,0x816,
+0x819,0x816,0x819,0x816,0x819,0x816,0x819,0x816,0x819,0x816,0x819,0x816,0x816,0x816,0x816,0x81c,
+0x816,0x81c,0x816,0x81c,0x816,0x816,0x816,0x816,0x816,0x816,0x81c,0x816,0x816,0x816,0x816,0x816,
+0x819,0xc6c,0xc6c,0x75,0x75,0x930,0x930,0x8fa,0x8fa,0x81f,0x822,0xc69,0x78,0x78,0x78,0x78,
+0x78,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,
+0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x834,0x1116,0x18f3,0x19d7,
+0x7b,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,
+0x837,0x837,0x837,0x7b,0x903,0x903,0x906,0x906,0x906,0x906,0x906,0x906,0x906,0x906,0x906,0x906,
+0x906,0x906,0x906,0x906,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,
+0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0xb1c,0x13c5,0x13c5,0x13c5,0x7e,
+0x7e,0x7e,0x7e,0x7e,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,
+0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,0x840,
+0x840,0xd71,0xd71,0x81,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,
+0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,
+0x846,0x846,0x846,0x81,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,
+0xb22,0x84,0x84,0x84,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,
+0xb28,0xb28,0xb28,0xb28,0xb28,0xc75,0xb28,0xb28,0xb28,0xc75,0xb28,0x87,0x87,0x87,0x87,0x87,
+0x87,0x87,0x87,0x87,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,
+0x11bb,0x11bb,0x11bb,0x11bb,0x9b4,0x9b4,0x9b4,0x9b4,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,0x8a,
+0x8a,0x8a,0x8a,0x8a,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,
+0x1230,0x1230,0x1230,0x1230,0x5e5,0x5e5,0x5e5,0x5e5,0x5e5,0x5e5,0x5e5,0x8d,0x8d,0x8d,0x8d,0x8d,
+0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x8d,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x8d,0x8d,0x8d,0x8d,
+0x8d,0xafb,0x5d6,0x5dc,0x5e2,0x5e2,0x5e2,0x5e2,0x5e2,0x5e2,0x5e2,0x5e2,0x5e2,0x5d9,0x5dc,0x5dc,
+0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x8d,0x5dc,0x5dc,0x5dc,0x5dc,
+0x5dc,0x8d,0x5dc,0x8d,0x5dc,0x5dc,0x8d,0x5dc,0x5dc,0x8d,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,0x5dc,
+0x5dc,0x5dc,0x5dc,0x5df,0x5f7,0x5f1,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,
+0x5f4,0x5fa,0x5f7,0x5f1,0x1344,0x1344,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
+0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,
+0x5f1,0x5f7,0x5f7,0x5f1,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
+0x90,0x90,0x90,0x90,0x5f4,0x5f1,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f1,0x5f4,0x5f1,0x5f1,
+0x5f4,0x5f4,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f4,0x5f4,0x5f4,0x5f1,
+0x5f4,0x5f4,0x5f4,0x5f4,0x90,0x90,0x5f4,0x5f4,0x5f4,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f4,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f4,0x5f4,0x5f1,0x5f1,0x90,0x90,0x90,0x90,
+0x90,0x90,0x90,0x90,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,0xb43,
+0xb43,0xb43,0xb43,0xb43,0x5f7,0x5f7,0x951,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5ee,0x5ee,
+0xbfd,0xd8c,0x90,0x90,0x858,0x86a,0x867,0x86a,0x867,0xc8a,0xc8a,0xd7d,0xd7a,0x85b,0x85b,0x85b,
+0x85b,0x86d,0x86d,0x86d,0x885,0x888,0x897,0x93,0x88b,0x88e,0x89a,0x89a,0x882,0x879,0x873,0x879,
+0x873,0x879,0x873,0x876,0x876,0x891,0x891,0x894,0x891,0x891,0x891,0x93,0x891,0x87f,0x87c,0x876,
+0x93,0x93,0x93,0x93,0x603,0x60f,0x603,0xc00,0x603,0x96,0x603,0x60f,0x603,0x60f,0x603,0x60f,
+0x603,0x60f,0x603,0x60f,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,
+0x60f,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x60c,
+0x606,0x96,0x96,0x600,0x756,0x759,0x76e,0x771,0x750,0x759,0x759,0x9c,0x738,0x73b,0x73b,0x73b,
+0x73b,0x738,0x738,0x9c,0x99,0x99,0x99,0x99,0x99,0x99,0x99,0x99,0x99,0xafe,0xafe,0xafe,
+0x9b7,0x732,0x612,0x612,0x9c,0x780,0x75f,0x750,0x759,0x756,0x750,0x762,0x753,0x74d,0x750,0x76e,
+0x765,0x75c,0x77d,0x750,0x77a,0x77a,0x77a,0x77a,0x77a,0x77a,0x77a,0x77a,0x77a,0x77a,0x76b,0x768,
+0x76e,0x76e,0x76e,0x780,0x741,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,
+0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,
+0x73e,0x73e,0x73e,0x9c,0x9c,0x9c,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x9c,0x9c,0x73e,0x73e,
+0x73e,0x73e,0x73e,0x73e,0x9c,0x9c,0x73e,0x73e,0x73e,0x73e,0x73e,0x73e,0x9c,0x9c,0x73e,0x73e,
+0x73e,0x9c,0x9c,0x9c,0xb46,0xb46,0xb46,0xb46,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,0x9f,
+0x9f,0x1890,0x1890,0x1890,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,
+0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xa2,0xa2,0xa2,0xa2,0xa2,0x165c,0x165c,0x165c,0x165c,
+0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0xb55,0xb55,0xb55,0xb55,
+0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,
+0xb55,0xb55,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xa8,0xa8,0xff9,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0x1716,0x1716,0x1716,0x1716,
+0x1716,0x1716,0x1716,0x1716,0x1716,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,
+0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xa8,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xab,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb79,0xab,0xb79,0xb79,0xab,0xab,0xb79,0xab,
+0xab,0xb79,0xb79,0xab,0xab,0xb79,0xb79,0xb79,0xb79,0xab,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb76,0xb76,0xb76,0xb76,0xab,0xb76,0xab,0xb76,0xb76,0xb76,0xb76,0xd02,0xb76,0xb76,
+0xab,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb76,0xb76,0xb76,0xb76,
+0xb79,0xb79,0xab,0xb79,0xb79,0xb79,0xb79,0xab,0xab,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xab,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xab,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xab,0xb79,0xb79,0xb79,0xb79,0xab,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xab,0xb79,0xab,0xab,0xab,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xab,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xdef,0xdef,0xab,0xab,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb76,0xb76,0xb76,0xb70,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xf06,0xf03,0xab,0xab,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,
+0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xae,0xb7f,0xae,0xae,0xae,0xae,0xae,0xae,
 0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,
-0xae,0xae,0xae,0xae,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,0xbe5,
-0xbe5,0xb1,0xbe5,0xbe5,0xbe5,0xbe5,0xbdf,0xbdf,0xbe2,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,
-0xb1,0xb1,0xb1,0xb1,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,
-0xbee,0xbee,0xbee,0xbee,0xbee,0xbee,0xbe8,0xbe8,0xbeb,0xc51,0xc51,0xb4,0xb4,0xb4,0xb4,0xb4,
-0xb4,0xb4,0xb4,0xb4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,
-0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf4,0xbf1,0xbf1,0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,
-0xb7,0xb7,0xb7,0xb7,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,0xbfa,
-0xbfa,0xba,0xbfa,0xbfa,0xbfa,0xba,0xbf7,0xbf7,0xba,0xba,0xba,0xba,0xba,0xba,0xba,0xba,
-0xba,0xba,0xba,0xba,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,
-0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,0xce4,
-0xce4,0x14e2,0x14e2,0xbd,0xcd5,0xcd5,0xcd5,0xce1,0xce1,0xce1,0xce1,0xcd5,0xcd5,0xce1,0xce1,0xce1,
-0xbd,0xbd,0xbd,0xbd,0xce1,0xce1,0xcd5,0xce1,0xce1,0xce1,0xce1,0xce1,0xce1,0xcd8,0xcd8,0xcd8,
-0xbd,0xbd,0xbd,0xbd,0xcdb,0xbd,0xbd,0xbd,0xce7,0xce7,0xcde,0xcde,0xcde,0xcde,0xcde,0xcde,
-0xcde,0xcde,0xcde,0xcde,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,
-0xcea,0xcea,0xcea,0xcea,0xcea,0xcea,0xc0,0xc0,0xcea,0xcea,0xcea,0xcea,0xcea,0xc0,0xc0,0xc0,
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,
-0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0xc3,0xc3,0x14e5,0x14e5,
-0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,
-0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0xc3,0xc3,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,
-0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,
-0x14e5,0x14e5,0xc3,0xc3,0xc3,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,
-0x14e5,0xc3,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x14e5,0x1863,0xc3,0xc3,0xc3,0xc3,0xc3,
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x16e9,0x16e9,0x16e9,0x16e9,0xc3,0xc3,0xc3,0xc3,
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xd11,0xd11,0xd11,0xd11,
-0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xc6,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,
-0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xc6,
-0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,
-0xd11,0xd11,0xd11,0xc6,0xd11,0xd11,0xc6,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,
-0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xc6,0xc6,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,
-0xd11,0xd11,0xd11,0xd11,0xd11,0xd11,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,
-0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,
-0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,
+0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xae,0xc0f,0xc0f,0xc0f,0xc0f,0xc0f,0xc0f,0xc0f,0xc0f,
+0xc0f,0xc0f,0xc0f,0xc0f,0xc0f,0xb1,0xc0f,0xc0f,0xc0f,0xc0f,0xc09,0xc09,0xc0c,0xb1,0xb1,0xb1,
+0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xb1,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,
+0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc18,0xc12,0xc12,0xc15,0xc7e,0xc7e,0xb4,
+0xb4,0xb4,0xb4,0xb4,0xb4,0xb4,0xb4,0xb4,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,
+0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1b,0xc1b,0xb7,0xb7,0xb7,0xb7,
+0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,0xb7,0xc24,0xc24,0xc24,0xc24,0xc24,0xc24,0xc24,0xc24,
+0xc24,0xc24,0xc24,0xc24,0xc24,0xba,0xc24,0xc24,0xc24,0xba,0xc21,0xc21,0xba,0xba,0xba,0xba,
+0xba,0xba,0xba,0xba,0xba,0xba,0xba,0xba,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,
 0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,
-0xd14,0xd14,0xd14,0xc9,0xc9,0xc9,0xc9,0xc9,0xd56,0xd56,0xd56,0xcc,0xcc,0xcc,0xcc,0xd50,
-0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,
-0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xcc,0xcc,0xcc,0xd53,0xd53,0xd53,0xd53,0xd53,
-0xd53,0xd53,0xd53,0xd53,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,
-0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,
-0xd1a,0xd1a,0xcf,0xd17,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,
-0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,0xd23,
-0xd23,0xd23,0xd2,0xd2,0xd20,0xd20,0xd20,0xd20,0xd20,0xd20,0xd20,0xd20,0xd20,0xd20,0xd2,0xd2,
-0xd2,0xd2,0xd2,0xd2,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,
-0x1821,0x1821,0x1821,0x1821,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd5,0xd5,0xd26,0xd5,0xd26,0xd26,
-0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,
-0xd26,0xd26,0xd26,0xd26,0xd26,0xd26,0xd5,0xd26,0xd26,0xd5,0xd5,0xd5,0xd26,0xd5,0xd5,0xd26,
-0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,
-0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd8,0xd8,0xd8,0xd8,0xd8,0xd8,0xd8,0xd8,0xd8,
-0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0x14e8,0x14e8,0x179a,0x179a,0xde,
-0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x135,0x135,0x135,0x135,
-0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,
-0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xdec,0xde3,0xde3,0xde9,0xde9,0xde3,0xe1,0xe1,0xde6,0xde6,
-0x10f5,0x10f5,0x10f5,0x10f5,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,
-0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,0xc4e,
-0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,
-0x14eb,0x14eb,0x14eb,0x14eb,0x14eb,0x14ee,0x1866,0x1866,0x1866,0x1866,0xe7,0x179d,0x1314,0x1137,0xee5,0xee5,
-0xdfe,0xdfb,0xdfe,0xdfb,0xdfb,0xdf2,0xdf2,0xdf2,0xdf2,0xdf2,0xdf2,0x1140,0x113d,0x1140,0x113d,0x113a,
-0x113a,0x113a,0x13da,0x13d7,0xea,0xea,0xea,0xea,0xea,0xdf8,0xdf5,0xdf5,0xdf5,0xdf2,0xdf8,0xdf5,
-0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,
-0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xed,0xed,0xed,0xed,0xed,0xed,0xed,0xed,0xed,
-0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xed,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xed,
-0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xed,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xe01,0xed,
-0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,
-0xe04,0xe04,0xe04,0xe04,0xe04,0xe04,0xe04,0xe04,0xe04,0xe04,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,
-0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xf3,0x13dd,0xf3,0xf3,0xf3,0xf3,0xf3,0x13dd,0xf3,0xf3,
-0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,
-0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xf6,
-0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,
-0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xf6,
-0xe22,0xe16,0xe16,0xe16,0xf9,0xe16,0xe16,0xf9,0xf9,0xf9,0xf9,0xf9,0xe16,0xe16,0xe16,0xe16,
-0xe22,0xe22,0xe22,0xe22,0xf9,0xe22,0xe22,0xe22,0xf9,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,
-0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,
-0xf9,0xf9,0xf9,0xf9,0xe13,0xe13,0xe13,0xf9,0xf9,0xf9,0xf9,0xe19,0xe1c,0xe1c,0xe1c,0xe1c,
-0xe1c,0xe1c,0xe1c,0xe1c,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xe1f,0xe1f,0xe1f,0xe1f,
-0xe1f,0xe1f,0xe25,0xe25,0xe1c,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xe31,0xe31,0xe31,0xe31,
-0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0x1146,0x1146,0xfc,0xfc,0xfc,0xfc,0xe31,0xe31,0xe31,0xe31,
-0xe31,0xe34,0xe34,0xe34,0xe31,0xe31,0xe34,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,
-0xe31,0xe31,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xe2e,0xe2e,0xe2e,0xe2e,0xe2e,0xe2e,0xe2e,0xe2e,
-0xe2e,0xe2e,0x1143,0xfc,0xfc,0xfc,0xe2b,0xe2b,0xe3a,0xe3a,0xe3a,0xe3a,0xff,0xff,0xff,0xff,
-0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe37,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xff,0xff,
-0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x14f7,0x14fd,0x14fa,0x1845,0x17a0,0x1869,0x1869,0x1869,
-0x1869,0x1869,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,
+0xd14,0xd14,0xd14,0xd14,0xd14,0x1512,0x1512,0xbd,0xd05,0xd05,0xd05,0xd11,0xd11,0xd11,0xd11,0xd05,
+0xd05,0xd11,0xd11,0xd11,0xbd,0xbd,0xbd,0xbd,0xd11,0xd11,0xd05,0xd11,0xd11,0xd11,0xd11,0xd11,
+0xd11,0xd08,0xd08,0xd08,0xbd,0xbd,0xbd,0xbd,0xd0b,0xbd,0xbd,0xbd,0xd17,0xd17,0xd0e,0xd0e,
+0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,
+0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xd1a,0xc0,0xc0,0xd1a,0xd1a,0xd1a,0xd1a,
+0xd1a,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x1515,0x1515,0x1515,0x1515,
+0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,
+0xc3,0xc3,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,
+0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0xc3,0xc3,0x1515,0x1515,0x1515,0x1515,
+0x1515,0x1515,0x1515,0x1515,0x1515,0xc3,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1893,0x192c,
+0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x1719,0x1719,0x1719,0x1719,
+0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0x192c,0xc3,
+0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xc6,0xd41,0xd41,0xd41,
+0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,
+0xd41,0xd41,0xd41,0xc6,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,
+0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xc6,0xd41,0xd41,0xc6,0xd41,0xd41,0xd41,0xd41,0xd41,
+0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xc6,0xc6,0xd41,0xd41,0xd41,0xd41,
+0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xd41,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,
+0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,
+0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xd44,0xd44,0xd44,0xd44,
+0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,
+0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xc9,0xc9,0xc9,0xc9,0xc9,0xd86,0xd86,0xd86,0xcc,
+0xcc,0xcc,0xcc,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,
+0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xd80,0xcc,0xcc,0xcc,0xd83,
+0xd83,0xd83,0xd83,0xd83,0xd83,0xd83,0xd83,0xd83,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,
+0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,
+0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xd4a,0xcf,0xd47,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,
+0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,
+0xd53,0xd53,0xd53,0xd53,0xd53,0xd53,0xd2,0xd2,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,0xd50,
+0xd50,0xd50,0xd2,0xd2,0xd2,0xd2,0xd2,0xd2,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,
+0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd5,0xd5,
+0xd56,0xd5,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,
+0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd56,0xd5,0xd56,0xd56,0xd5,0xd5,0xd5,
+0xd56,0xd5,0xd5,0xd56,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,
+0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd8,0xd8,0xd8,0xd8,0xd8,
+0xd8,0xd8,0xd8,0xd8,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0x1518,
+0x1518,0x17ca,0x17ca,0xde,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,
+0x135,0x135,0x135,0x135,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,
+0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe1c,0xe13,0xe13,0xe19,0xe19,0xe13,
+0xe1,0xe1,0xe16,0xe16,0x1125,0x1125,0x1125,0x1125,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,0xe4,
+0xe4,0xe4,0xe4,0xe4,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,0xc7b,
+0xc7b,0xc7b,0xc7b,0xc7b,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x151b,0x151b,0x151b,0x151b,0x151b,
+0x151b,0x151b,0x151b,0x151b,0x151b,0x151b,0x151b,0x151b,0x151b,0x151e,0x1896,0x1896,0x1896,0x1896,0xe7,0x17cd,
+0x1350,0x1167,0xf15,0xf15,0xe2e,0xe2b,0xe2e,0xe2b,0xe2b,0xe22,0xe22,0xe22,0xe22,0xe22,0xe22,0x1170,
+0x116d,0x1170,0x116d,0x116a,0x116a,0x116a,0x140d,0x140a,0xea,0xea,0xea,0xea,0xea,0xe28,0xe25,0xe25,
+0xe25,0xe22,0xe28,0xe25,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,
+0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xed,0xed,0xed,0xed,0xed,
+0xed,0xed,0xed,0xed,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xed,0xe31,0xe31,0xe31,0xe31,
+0xe31,0xe31,0xe31,0xed,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xed,0xe31,0xe31,0xe31,0xe31,
+0xe31,0xe31,0xe31,0xed,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,0xe37,
+0xe37,0xe37,0xe37,0xe37,0xe34,0xe34,0xe34,0xe34,0xe34,0xe34,0xe34,0xe34,0xe34,0xe34,0xf0,0xf0,
+0xf0,0xf0,0xf0,0xf0,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xf3,0x1410,0xf3,0xf3,0xf3,0xf3,
+0xf3,0x1410,0xf3,0xf3,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,
+0xe94,0xe94,0xe94,0xe94,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,
+0xe40,0xe40,0xe40,0xf6,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,
+0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,0xe3d,
+0xe3d,0xe3d,0xe3d,0xf6,0xe52,0xe46,0xe46,0xe46,0xf9,0xe46,0xe46,0xf9,0xf9,0xf9,0xf9,0xf9,
+0xe46,0xe46,0xe46,0xe46,0xe52,0xe52,0xe52,0xe52,0xf9,0xe52,0xe52,0xe52,0xf9,0xe52,0xe52,0xe52,
+0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,0xe52,
+0xe52,0xe52,0xe52,0xe52,0x1932,0x1932,0xf9,0xf9,0xe43,0xe43,0xe43,0xf9,0xf9,0xf9,0xf9,0xe49,
+0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0x192f,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,
+0xe4f,0xe4f,0xe4f,0xe4f,0xe4f,0xe4f,0xe55,0xe55,0xe4c,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,0xf9,
+0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0x1176,0x1176,0xfc,0xfc,0xfc,0xfc,
+0xe61,0xe61,0xe61,0xe61,0xe61,0xe64,0xe64,0xe64,0xe61,0xe61,0xe64,0xe61,0xe61,0xe61,0xe61,0xe61,
+0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xe5e,0xe5e,0xe5e,0xe5e,
+0xe5e,0xe5e,0xe5e,0xe5e,0xe5e,0xe5e,0x1173,0xfc,0xfc,0xfc,0xe5b,0xe5b,0xe6a,0xe6a,0xe6a,0xe6a,
+0xff,0xff,0xff,0xff,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe67,0xe6a,0xe6a,0xe6a,
+0xe6a,0xe6a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x1527,0x152d,0x152a,0x1875,
+0x17d0,0x1899,0x1899,0x1899,0x1899,0x1899,0x1938,0x1935,0x193b,0x1935,0x193b,0x102,0x102,0x102,0x102,0x102,
 0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,
-0x102,0x102,0x102,0x102,0xe61,0xe61,0xe61,0xe5e,0xe5e,0xe55,0xe55,0xe5e,0xe5b,0xe5b,0xe5b,0xe5b,
-0x105,0x105,0x105,0x105,0x12b1,0x12b1,0x12b1,0x12b1,0x12b1,0x12b1,0x12b4,0x12b4,0x12b7,0x12b4,0x159,0x159,
-0x159,0x159,0x159,0x159,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0x13e9,0x13e9,0x108,0x108,0x108,0x108,
-0x108,0x108,0x108,0xe67,0x131a,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,
-0x108,0x108,0x108,0x1317,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,0xc21,
-0xc21,0xc21,0xc21,0xc21,0xe94,0xe85,0xe7f,0xe91,0xe8e,0xe88,0xe88,0xe97,0xe82,0xe8b,0x10b,0x10b,
-0x10b,0x10b,0x10b,0x10b,0xf18,0xf18,0xf03,0xf18,0xf1b,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,
-0x111,0x111,0x111,0x111,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf24,0xf24,
-0xf09,0xf0f,0xf24,0xf24,0xf0c,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf06,
-0xf06,0xf06,0xf06,0xf06,0xf06,0xf06,0xf06,0xf06,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,0xf09,
-0xf09,0x111,0x111,0x111,0x1320,0x131d,0x1320,0x131d,0x1320,0x131d,0x1320,0x131d,0x1320,0x131d,0x13ef,0x1509,
-0x1509,0x1509,0x17a3,0x114,0x1509,0x1509,0x16f2,0x16f2,0x16f2,0x16ec,0x16f2,0x16ec,0x114,0x114,0x114,0x114,
+0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0x102,0xe91,0xe91,0xe91,0xe8e,
+0xe8e,0xe85,0xe85,0xe8e,0xe8b,0xe8b,0xe8b,0xe8b,0x105,0x105,0x105,0x105,0x12ed,0x12ed,0x12ed,0x12f0,
+0x12f0,0x12f0,0x12e7,0x12e7,0x12ea,0x12e7,0x159,0x159,0x159,0x159,0x159,0x159,0xe94,0xe94,0xe94,0xe94,
+0xe94,0xe94,0x141c,0x141c,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0xe97,0x1356,0x108,0x108,0x108,
+0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x108,0x1353,0xc4b,0xc4b,0xc4b,0xc4b,
+0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4e,0xec4,0xeb5,0xeaf,0xec1,
+0xebe,0xeb8,0xeb8,0xec7,0xeb2,0xebb,0x10b,0x10b,0x10b,0x10b,0x10b,0x10b,0xf48,0xf48,0xf33,0xf48,
+0xf4b,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0x111,0x111,0x111,0x111,0xf42,0xf42,0xf42,0xf42,
+0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf54,0xf54,0xf39,0xf3f,0xf54,0xf54,0xf3c,0xf39,0xf39,0xf39,
+0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0xf36,0xf36,0xf36,0xf36,0xf36,0xf36,0xf36,0xf36,0xf36,
+0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0xf39,0x111,0x111,0x111,0x135c,0x1359,0x135c,0x1359,
+0x135c,0x1359,0x135c,0x1359,0x135c,0x1359,0x1422,0x1539,0x1539,0x1539,0x17d3,0x1944,0x1539,0x1539,0x1722,0x1722,
+0x1722,0x171c,0x1722,0x171c,0x1947,0x1944,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,
 0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,
-0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x1506,
-0x13f2,0x13f2,0x131d,0x1020,0x1020,0x1020,0x1020,0x1020,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,
-0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf30,0xf30,0xf36,0xf36,
-0x117,0x117,0x117,0x117,0x117,0x117,0x117,0x117,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,
-0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf3f,0xf39,0xf39,
-0xf39,0xf39,0x114f,0x114f,0x11a,0x11a,0x11a,0xf3c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,
-0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,
-0x150c,0x16f5,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,
+0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x114,0x1536,0x1425,0x1425,0x1359,0x1050,
+0x1050,0x1050,0x1050,0x1050,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,
+0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf60,0xf60,0xf66,0xf66,0x117,0x117,0x117,0x117,
+0x117,0x117,0x117,0x117,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,
+0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf6f,0xf69,0xf69,0xf69,0xf69,0x117f,0x117f,
+0x11a,0x11a,0x11a,0xf6c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,
+0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x1725,0x11d,0x11d,
+0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,
 0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,0x11d,
-0x11d,0x11d,0x11d,0x11d,0xf48,0xf48,0xf48,0x1512,0x1512,0x1512,0x1512,0x1512,0x1512,0x1512,0x1512,0x1512,
-0x1512,0x1512,0x1512,0x120,0xf45,0xf45,0xf45,0xf45,0x150f,0x120,0x120,0x120,0x120,0x120,0x120,0x120,
-0x120,0x120,0x120,0x120,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,
-0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0xf4b,0x123,0x123,0x123,0x123,0x123,0x123,0x123,0x123,0x123,0x123,
-0x123,0x123,0x123,0x123,0x1047,0x1047,0x1047,0x1047,0x1044,0x1044,0x1044,0x1044,0x1044,0x1044,0x1044,0x1044,
-0x1035,0x1035,0x1035,0x1035,0x1035,0x1035,0x1035,0x1035,0x1044,0x1044,0x103b,0x1038,0x126,0x126,0x126,0x104a,
-0x104a,0x103e,0x103e,0x103e,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x1041,0x126,0x126,
-0x126,0x1047,0x1047,0x1047,0x104d,0x104d,0x104d,0x104d,0x104d,0x104d,0x104d,0x104d,0x104d,0x104d,0x1050,0x1050,
-0x1050,0x1050,0x1050,0x1050,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1065,0x1065,
+0xf78,0xf78,0xf78,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x1542,0x120,
+0xf75,0xf75,0xf75,0xf75,0x153f,0x120,0x120,0x120,0x120,0x120,0x120,0x120,0x120,0x120,0x120,0x120,
+0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,0xf7b,
+0xf7b,0xf7b,0x194a,0x194a,0x194a,0x194a,0x194a,0x194a,0x194a,0x123,0x123,0x123,0x123,0x123,0x123,0x123,
+0x1077,0x1077,0x1077,0x1077,0x1074,0x1074,0x1074,0x1074,0x1074,0x1074,0x1074,0x1074,0x1065,0x1065,0x1065,0x1065,
+0x1065,0x1065,0x1065,0x1065,0x1074,0x1074,0x106b,0x1068,0x126,0x126,0x126,0x107a,0x107a,0x106e,0x106e,0x106e,
+0x1071,0x1071,0x1071,0x1071,0x1071,0x1071,0x1071,0x1071,0x1071,0x1071,0x126,0x126,0x126,0x1077,0x1077,0x1077,
+0x107d,0x107d,0x107d,0x107d,0x107d,0x107d,0x107d,0x107d,0x107d,0x107d,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,
+0x1092,0x1092,0x1092,0x1092,0x1092,0x1092,0x1092,0x1092,0x1092,0x1092,0x1095,0x1095,0x129,0x129,0x129,0x129,
 0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,0x129,
-0x129,0x129,0x129,0x129,0x108c,0x108c,0x108c,0x108c,0x1086,0x17a6,0x12c,0x12c,0x12c,0x12c,0x12c,0x12c,
-0x12c,0x12c,0x1092,0x1092,0x1089,0x1089,0x1089,0x1089,0x1089,0x1089,0x1089,0x1089,0x1089,0x1089,0x12c,0x12c,
-0x12c,0x12c,0x12c,0x12c,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10a4,0x10a4,0x10a4,0x10a4,0x10a4,
-0x10a4,0x10a4,0x10a4,0x10a4,0x10a4,0x10a4,0x10aa,0x10ad,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,
-0x12f,0x12f,0x12f,0x10a7,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10b3,0x10b3,0x10b3,
-0x10b3,0x10b3,0x10b3,0x10bc,0x10bc,0x10b3,0x10b3,0x10bc,0x10bc,0x10b3,0x10b3,0x132,0x132,0x132,0x132,0x132,
-0x132,0x132,0x132,0x132,0x10bf,0x10bf,0x10bf,0x10b3,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,
-0x10b3,0x10bc,0x132,0x132,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x132,0x132,
-0x10b6,0x10c2,0x10c2,0x10c2,0x151e,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,
+0x10bc,0x10bc,0x10bc,0x10bc,0x10b6,0x17d6,0x12c,0x12c,0x12c,0x12c,0x12c,0x12c,0x12c,0x12c,0x10c2,0x10c2,
+0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x10b9,0x12c,0x12c,0x12c,0x12c,0x12c,0x12c,
+0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10d4,0x10d4,0x10d4,0x10d4,0x10d4,0x10d4,0x10d4,0x10d4,0x10d4,
+0x10d4,0x10d4,0x10da,0x10dd,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x12f,0x10d7,
+0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10e3,0x10e3,0x10e3,0x10e3,0x10e3,0x10e3,0x10ec,
+0x10ec,0x10e3,0x10e3,0x10ec,0x10ec,0x10e3,0x10e3,0x132,0x132,0x132,0x132,0x132,0x132,0x132,0x132,0x132,
+0x10ef,0x10ef,0x10ef,0x10e3,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10e3,0x10ec,0x132,0x132,
+0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x10e9,0x132,0x132,0x10e6,0x10f2,0x10f2,0x10f2,
+0x154e,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,
 0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,0x135,
-0x135,0x135,0x135,0x135,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,
-0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,0x10c8,
-0x10c8,0x10cb,0x138,0x138,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,
-0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,
-0x10ce,0x13b,0x13b,0x13b,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,
-0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,
-0x13e,0x13e,0x13e,0x13e,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,
-0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x10d7,0x141,0x141,
-0x141,0x141,0x141,0x10d4,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,
-0x144,0x144,0x144,0x144,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,
-0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,
-0x147,0x147,0x147,0x147,0x1155,0x1155,0x1155,0x1155,0x115e,0x1155,0x1155,0x1155,0x115e,0x1155,0x1155,0x1155,
-0x1155,0x1152,0x14a,0x14a,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,0x115b,
-0x115b,0x115b,0x115b,0x14a,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,
-0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,
-0x14d,0x14d,0x14d,0x14d,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,
-0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x1179,0x1164,0x1179,0x1164,0x1164,0x1164,0x1164,
-0x1164,0x1164,0x1164,0x150,0x116d,0x1176,0x1164,0x1176,0x1176,0x1164,0x1164,0x1164,0x1164,0x1164,0x1164,0x1164,
-0x1164,0x1179,0x1179,0x1179,0x1179,0x1179,0x1179,0x1164,0x1164,0x116a,0x116a,0x116a,0x116a,0x116a,0x116a,0x116a,
-0x116a,0x150,0x150,0x1167,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x150,0x150,
-0x150,0x150,0x150,0x150,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x1173,0x150,0x150,
-0x150,0x150,0x150,0x150,0x1170,0x1170,0x1170,0x1170,0x1170,0x1170,0x1170,0x117f,0x1182,0x1182,0x1182,0x1182,
-0x1170,0x1170,0x150,0x150,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,
-0x1569,0x1569,0x1566,0x1cb,0x12c6,0x12a5,0x12c0,0x12c0,0x12c0,0x12c0,0x12c0,0x12c0,0x12c0,0x12a8,0x12a8,0x12a8,
-0x12a8,0x12c0,0x12a8,0x12a8,0x12a8,0x12a8,0x12ae,0x1494,0x149a,0x1497,0x1491,0x18e4,0x16bf,0x16bf,0x153,0x153,
-0x153,0x153,0x153,0x153,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,
-0x1197,0x1197,0x1197,0x1197,0x118e,0x118e,0x1191,0x119a,0x1194,0x1194,0x1194,0x119a,0x156,0x156,0x156,0x156,
-0x156,0x156,0x156,0x156,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,
-0x119d,0x119d,0x119d,0x119d,0x119d,0x12cc,0x11a3,0x12cf,0x11a3,0x11a3,0x11a3,0x11a3,0x11a0,0x11a0,0x11a0,0x11a3,
-0x16fb,0x16fe,0x15c,0x15c,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,
-0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,0x1293,
-0x1293,0x15f,0x15f,0x15f,0x11b8,0x11ac,0x11ac,0x11ac,0x11ac,0x11ac,0x11ac,0x11af,0x11be,0x11be,0x11ac,0x11ac,
-0x11ac,0x11ac,0x162,0x12ba,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x11b2,0x162,0x162,
-0x162,0x162,0x11ac,0x11ac,0x11dc,0x11d0,0x11dc,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,
-0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x165,0x11d9,
-0x11d9,0x11df,0x11d3,0x11d6,0x11f4,0x11f4,0x11f4,0x11ee,0x11ee,0x11e5,0x11ee,0x11ee,0x11e5,0x11ee,0x11ee,0x11f7,
-0x11f1,0x11e8,0x168,0x168,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x11eb,0x168,0x168,
-0x168,0x168,0x168,0x168,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x11fd,0x16b,0x16b,0x16b,0x16b,0x11fa,
-0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,
-0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x16b,0x16b,0x16b,0x16b,
-0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,
-0x1206,0x1206,0x1206,0x1206,0x1206,0x1206,0x16e,0x1203,0x1200,0x1200,0x1200,0x1200,0x1200,0x1200,0x1200,0x1200,
-0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,
-0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x171,0x171,0x171,0x120f,0x1212,0x1212,0x1212,0x1212,0x1212,0x1212,
-0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,
-0x121b,0x121b,0x121b,0x121b,0x121b,0x121b,0x174,0x174,0x1218,0x1218,0x1218,0x1218,0x1218,0x1218,0x1218,0x1218,
-0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,0x1221,
-0x1221,0x1221,0x1221,0x177,0x177,0x177,0x177,0x177,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,
-0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,
-0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x17d,
-0x1242,0x1242,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,0x180,
-0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,
-0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x152a,0x152a,0x186,0x186,0x186,
-0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,
-0x126f,0x126f,0x126f,0x1272,0x1272,0x1272,0x1251,0x186,0x1374,0x127b,0x1374,0x1374,0x1374,0x1374,0x1374,0x1374,
-0x1374,0x1374,0x1374,0x1374,0x1374,0x127b,0x1374,0x127b,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,
-0x1371,0x1371,0x1401,0x1401,0x186,0x186,0x186,0x186,0x1377,0x1377,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,
-0x1371,0x1278,0x1371,0x1278,0x1278,0x1371,0x1377,0x127e,0x1824,0x1824,0x1824,0x1824,0x1824,0x1824,0x1824,0x1824,
-0x1824,0x1824,0x1824,0x1824,0x1824,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,
+0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,
+0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10f8,0x10fb,0x138,0x138,
+0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,
+0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x10fe,0x13b,0x13b,0x13b,
+0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,
+0x1101,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,0x13e,
+0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,
+0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x1107,0x141,0x141,0x141,0x141,0x141,0x1104,
+0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x144,0x144,0x144,0x144,
+0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,
+0x110d,0x110d,0x110d,0x110d,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,0x147,
+0x1185,0x1185,0x1185,0x1185,0x118e,0x1185,0x1185,0x1185,0x118e,0x1185,0x1185,0x1185,0x1185,0x1182,0x14a,0x14a,
+0x118b,0x118b,0x118b,0x118b,0x118b,0x118b,0x118b,0x1191,0x118b,0x1191,0x118b,0x118b,0x118b,0x1191,0x1191,0x14a,
+0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,
+0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,0x14d,
+0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,
+0x11af,0x11af,0x11af,0x11af,0x11af,0x11ac,0x1197,0x11ac,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x150,
+0x11a0,0x11a9,0x1197,0x11a9,0x11a9,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x11ac,0x11ac,0x11ac,
+0x11ac,0x11ac,0x11ac,0x1197,0x1197,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x119d,0x150,0x150,0x119a,
+0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x150,0x150,0x150,0x150,0x150,0x150,
+0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x11a6,0x150,0x150,0x150,0x150,0x150,0x150,
+0x11a3,0x11a3,0x11a3,0x11a3,0x11a3,0x11a3,0x11a3,0x11b2,0x11b5,0x11b5,0x11b5,0x11b5,0x11a3,0x11a3,0x150,0x150,
+0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1599,0x1596,0x1c8,
+0x1302,0x12e1,0x12f9,0x12f9,0x12f9,0x12f9,0x12f9,0x12f9,0x12f9,0x12d8,0x12e4,0x12d8,0x12d8,0x12ff,0x12d8,0x12d8,
+0x12d8,0x12d8,0x12de,0x14c4,0x14ca,0x14c7,0x14c7,0x1914,0x16ef,0x16ef,0x153,0x153,0x153,0x153,0x153,0x153,
+0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,
+0x11c1,0x11c1,0x11c4,0x11cd,0x11c7,0x11c7,0x11c7,0x11cd,0x156,0x156,0x156,0x156,0x156,0x156,0x156,0x156,
+0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,
+0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x12c6,0x15c,0x15c,0x15c,
+0x11eb,0x11df,0x11df,0x11df,0x11df,0x11df,0x11df,0x11e2,0x11f1,0x11f1,0x11df,0x11df,0x11df,0x11df,0x15f,0x12f3,
+0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x11e5,0x15f,0x15f,0x15f,0x15f,0x11df,0x11df,
+0x120f,0x1203,0x120f,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,
+0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x162,0x120c,0x120c,0x1212,0x1206,0x1209,
+0x1227,0x1227,0x1227,0x1221,0x1221,0x1218,0x1221,0x1221,0x1218,0x1221,0x1221,0x122a,0x1224,0x121b,0x165,0x165,
+0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x121e,0x165,0x165,0x165,0x165,0x165,0x165,
+0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x1230,0x168,0x168,0x168,0x168,0x122d,0x122d,0x122d,0x122d,0x122d,
+0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,
+0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x122d,0x168,0x168,0x168,0x168,0x1239,0x1239,0x1239,0x1239,
+0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,0x1239,
+0x1239,0x1239,0x16b,0x1236,0x1233,0x1233,0x1233,0x1233,0x1233,0x1233,0x1233,0x1233,0x1248,0x1248,0x1248,0x1248,
+0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,
+0x1248,0x1248,0x16e,0x16e,0x16e,0x1242,0x1245,0x1245,0x1245,0x1245,0x1245,0x1245,0x124e,0x124e,0x124e,0x124e,
+0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,0x124e,
+0x124e,0x124e,0x171,0x171,0x124b,0x124b,0x124b,0x124b,0x124b,0x124b,0x124b,0x124b,0x1254,0x1254,0x1254,0x1254,
+0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x1254,0x174,
+0x174,0x174,0x174,0x174,0x1251,0x1251,0x1251,0x1251,0x1251,0x1251,0x1251,0x1251,0x125a,0x125a,0x125a,0x125a,
+0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,
+0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x125a,0x17a,0x1275,0x1275,0x17d,0x17d,
+0x17d,0x17d,0x17d,0x17d,0x17d,0x17d,0x17d,0x17d,0x17d,0x1953,0x17d,0x17d,0x14a3,0x14a3,0x14a3,0x14a3,
+0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x12a2,0x12a2,0x12a2,0x12a2,
+0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x155a,0x155a,0x183,0x183,0x183,0x12a2,0x12a2,0x12a2,0x12a2,
+0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x13ad,0x13ad,0x13ad,0x13ad,
+0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x1434,0x1434,0x183,0x183,0x183,0x183,0x13b3,0x13b3,0x13ad,0x13ad,
+0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x12ab,0x13ad,0x12ab,0x12ab,0x13ad,0x13b3,0x12b1,0x1854,0x1854,0x1854,0x1854,
+0x1854,0x1854,0x1854,0x1854,0x1854,0x1854,0x1854,0x1854,0x1854,0x183,0x183,0x183,0x183,0x183,0x183,0x183,
+0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,
+0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x183,0x1365,0x1365,
+0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,
+0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x12d2,0x13ce,0x13cb,0x186,0x186,0x186,0x186,0x186,
+0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,
+0x12cc,0x12cc,0x12cf,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,0x12cc,
+0x12cc,0x12cc,0x12cc,0x12cf,0x12cc,0x12cc,0x13ce,0x13ce,0x13ce,0x13ce,0x13ce,0x13cb,0x13ce,0x13ce,0x13ce,0x1857,
+0x186,0x186,0x186,0x186,0x12c9,0x12c9,0x12c9,0x12c9,0x12c9,0x12c9,0x12c9,0x12c9,0x12c9,0x186,0x186,0x186,
+0x186,0x186,0x186,0x186,0x13f2,0x13f2,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,
+0x186,0x186,0x186,0x186,0x18f9,0x18f9,0x18f9,0x18f9,0x18f9,0x18f9,0x186,0x186,0x186,0x186,0x186,0x186,
 0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,
-0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,
-0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,0x1329,
-0x1329,0x1329,0x1329,0x1329,0x129f,0x1392,0x138f,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,
-0x189,0x189,0x189,0x189,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x129c,0x1299,
-0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x129c,
-0x1299,0x1299,0x1392,0x1392,0x1392,0x1392,0x1392,0x138f,0x1392,0x1392,0x1392,0x1827,0x189,0x189,0x189,0x189,
-0x1296,0x1296,0x1296,0x1296,0x1296,0x1296,0x1296,0x1296,0x1296,0x189,0x189,0x189,0x189,0x189,0x189,0x189,
-0x13bf,0x13bf,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,
-0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,
-0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,
-0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x189,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,
-0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,0x1332,
-0x1332,0x132c,0x132c,0x132c,0x18c,0x18c,0x132f,0x18c,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1335,0x133e,
-0x1338,0x1338,0x133e,0x133e,0x133e,0x1338,0x133e,0x1338,0x1338,0x1338,0x1341,0x1341,0x18f,0x18f,0x18f,0x18f,
-0x18f,0x18f,0x18f,0x18f,0x133b,0x133b,0x133b,0x133b,0x192,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x192,
-0x192,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x192,0x192,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x192,
-0x192,0x192,0x192,0x192,0x192,0x192,0x192,0x192,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x192,
-0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x1347,0x192,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,
-0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x134a,0x134a,0x134a,0x134a,0x134a,0x134a,0x134d,0x135f,
-0x135f,0x1353,0x1353,0x1353,0x1353,0x1353,0x195,0x195,0x195,0x195,0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,
-0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,0x1350,0x1356,0x1356,0x1356,0x1356,0x1356,0x1356,
-0x1356,0x1356,0x1356,0x1356,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x195,
-0x195,0x195,0x195,0x152d,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,
-0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x198,0x198,0x198,
-0x198,0x198,0x198,0x198,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,
-0x1365,0x1365,0x1365,0x19b,0x19b,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,
-0x1365,0x1365,0x1365,0x1530,0x19b,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,
-0x1365,0x1365,0x1365,0x139b,0x19b,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,0x1365,
-0x1365,0x1365,0x1365,0x1365,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,
-0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x1530,0x19b,0x19b,0x19b,0x19b,0x19b,0x19b,
-0x19b,0x19b,0x19b,0x19b,0x13b9,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x1545,0x1545,0x1545,0x1545,0x1545,0x1548,
-0x16b6,0x1548,0x1548,0x1548,0x1782,0x1830,0x1830,0x186c,0x186c,0x19e,0x19e,0x19e,0x19e,0x19e,0x19e,0x19e,
-0x19e,0x19e,0x19e,0x19e,0x1548,0x1548,0x1548,0x1548,0x1548,0x1548,0x1545,0x1545,0x1545,0x1548,0x1545,0x16b3,
-0x16b3,0x19e,0x19e,0x19e,0x1548,0x1545,0x1545,0x1548,0x1830,0x1830,0x1830,0x18cf,0x18cf,0x19e,0x19e,0x19e,
-0x19e,0x19e,0x19e,0x19e,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,
-0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,
-0x1a1,0x1a1,0x1a1,0x1a1,0x140d,0x154e,0x140d,0x140d,0x140d,0x140d,0x140d,0x140d,0x140d,0x140d,0x140d,0x140d,
-0x140d,0x154e,0x154e,0x154e,0x154e,0x154e,0x154e,0x1707,0x1707,0x1a4,0x17b2,0x17b2,0x17b2,0x17b2,0x17b2,0x17b2,
-0x17b2,0x17b2,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,
-0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x17af,0x17af,0x17af,0x17af,0x17af,0x17af,0x17af,0x17af,
-0x17af,0x17af,0x17af,0x17af,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,
-0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,
-0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1a7,0x1413,0x1a7,0x1a7,0x1413,0x1a7,0x1413,0x1413,0x1413,
-0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1a7,0x1413,
-0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1413,0x1a7,0x1a7,0x1a7,0x1a7,0x1413,0x1a7,0x1413,0x1a7,0x1413,
-0x1a7,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1a7,0x1413,0x1a7,0x1a7,0x1413,0x1a7,0x1413,0x1a7,0x1413,
-0x1a7,0x1413,0x1a7,0x1413,0x1a7,0x1413,0x1413,0x1a7,0x1413,0x1a7,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1a7,
-0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1413,
-0x1413,0x1a7,0x1413,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,
-0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,
-0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1413,0x1413,0x1413,0x1a7,0x1413,0x1413,0x1413,0x1413,0x1413,0x1a7,0x1413,
-0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,0x1413,
-0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,
-0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,
-0x1410,0x1410,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,
-0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1416,0x1416,0x1416,0x1416,0x1416,0x1425,0x1416,0x1419,0x1419,
-0x1416,0x1416,0x1416,0x141c,0x141c,0x1aa,0x1422,0x1422,0x1422,0x1422,0x1422,0x1422,0x1422,0x1422,0x1422,0x1422,
-0x141f,0x142b,0x142b,0x142b,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,
+0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x186,0x136e,0x136e,0x136e,0x136e,
+0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,0x136e,
+0x136e,0x136e,0x136e,0x136e,0x136e,0x1368,0x1368,0x1368,0x189,0x189,0x136b,0x189,0x1380,0x1380,0x1380,0x1380,
+0x1380,0x1380,0x1371,0x137a,0x1374,0x1374,0x137a,0x137a,0x137a,0x1374,0x137a,0x1374,0x1374,0x1374,0x137d,0x137d,
+0x18c,0x18c,0x18c,0x18c,0x18c,0x18c,0x18c,0x18c,0x1377,0x1377,0x1377,0x1377,0x18f,0x1383,0x1383,0x1383,
+0x1383,0x1383,0x1383,0x18f,0x18f,0x1383,0x1383,0x1383,0x1383,0x1383,0x1383,0x18f,0x18f,0x1383,0x1383,0x1383,
+0x1383,0x1383,0x1383,0x18f,0x18f,0x18f,0x18f,0x18f,0x18f,0x18f,0x18f,0x18f,0x1383,0x1383,0x1383,0x1383,
+0x1383,0x1383,0x1383,0x18f,0x1383,0x1383,0x1383,0x1383,0x1383,0x1383,0x1383,0x18f,0x15f6,0x15f6,0x15f6,0x15f6,
+0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x1386,0x1386,0x1386,0x1386,
+0x1386,0x1386,0x1389,0x139b,0x139b,0x138f,0x138f,0x138f,0x138f,0x138f,0x192,0x192,0x192,0x192,0x138c,0x138c,
+0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x1392,0x1392,
+0x1392,0x1392,0x1392,0x1392,0x1392,0x1392,0x1392,0x1392,0x192,0x192,0x192,0x192,0x192,0x192,0x192,0x192,
+0x192,0x192,0x192,0x192,0x192,0x192,0x192,0x155d,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,
+0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,
+0x139e,0x195,0x195,0x195,0x195,0x195,0x195,0x195,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
+0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x198,0x198,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
+0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x1560,0x198,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
+0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13d7,0x198,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
+0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,
+0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x1560,0x198,0x198,
+0x198,0x198,0x198,0x198,0x198,0x198,0x198,0x198,0x13ec,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x1575,0x1575,
+0x1575,0x1575,0x1575,0x1578,0x16e6,0x1578,0x1578,0x1578,0x17b2,0x1860,0x1860,0x189c,0x189c,0x19b,0x19b,0x19b,
+0x19b,0x19b,0x19b,0x19b,0x19b,0x19b,0x19b,0x19b,0x1578,0x1578,0x1578,0x1578,0x1578,0x1578,0x1575,0x1575,
+0x1575,0x1578,0x1575,0x16e3,0x16e3,0x19b,0x19b,0x19b,0x1578,0x1575,0x1575,0x1578,0x1860,0x1860,0x1860,0x18ff,
+0x18ff,0x19dd,0x19b,0x19b,0x19b,0x19b,0x19b,0x19b,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,
+0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x19e,0x19e,0x19e,0x19e,
+0x19e,0x19e,0x19e,0x19e,0x19e,0x19e,0x19e,0x19e,0x1440,0x157e,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,
+0x1440,0x1440,0x1440,0x1440,0x1440,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x1737,0x1737,0x1a1,0x17e2,0x17e2,
+0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,
+0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1a1,0x1959,0x17df,0x17df,0x17df,0x17df,
+0x17df,0x17df,0x17df,0x17df,0x17df,0x17df,0x17df,0x17df,0x1446,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1a4,0x1446,0x1a4,0x1a4,0x1446,
+0x1a4,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,
+0x1a4,0x1446,0x1a4,0x1446,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1446,0x1a4,0x1a4,0x1a4,0x1a4,0x1446,
+0x1a4,0x1446,0x1a4,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1a4,0x1446,0x1a4,0x1a4,0x1446,
+0x1a4,0x1446,0x1a4,0x1446,0x1a4,0x1446,0x1a4,0x1446,0x1a4,0x1446,0x1446,0x1a4,0x1446,0x1a4,0x1a4,0x1446,
+0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,
+0x1a4,0x1446,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1446,0x1446,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1446,0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1a4,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,0x1446,
+0x1446,0x1446,0x1446,0x1446,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,
+0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,
+0x1a4,0x1a4,0x1a4,0x1a4,0x1443,0x1443,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,0x1a4,
+0x1a4,0x1a4,0x1a4,0x1a4,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x1449,0x1449,0x1449,0x1449,0x1449,
+0x1458,0x1449,0x144c,0x144c,0x1449,0x1449,0x1449,0x144f,0x144f,0x1a7,0x1455,0x1455,0x1455,0x1455,0x1455,0x1455,
+0x1455,0x1455,0x1455,0x1455,0x1452,0x145e,0x145e,0x145e,0x195f,0x195c,0x195c,0x1a7,0x1a7,0x1a7,0x1a7,0x1a7,
+0x1a7,0x1a7,0x1a7,0x1a7,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,
+0x1608,0x1608,0x1608,0x1608,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x146a,0x1467,
+0x1461,0x1461,0x1467,0x1467,0x1470,0x1470,0x146a,0x146d,0x146d,0x1467,0x1464,0x1aa,0x1aa,0x1aa,0x1aa,0x1aa,
+0x1aa,0x1aa,0x1aa,0x1aa,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,
+0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1ad,0x1ad,0x1ad,0x1ad,
+0x173a,0x173a,0x1473,0x1473,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,
+0x173a,0x173a,0x173a,0x173a,0x1ad,0x1ad,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,
+0x173a,0x173a,0x173a,0x173a,0x147f,0x147f,0x147f,0x147f,0x147f,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,
+0x1b0,0x1b0,0x1b0,0x1b0,0x147f,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,
+0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,
+0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x147c,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,
+0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1b0,0x1479,0x1479,0x1479,0x1479,0x1482,0x1482,0x1482,0x1482,0x1482,
+0x1482,0x1482,0x1482,0x1482,0x1482,0x1482,0x1482,0x1482,0x1494,0x1497,0x149a,0x149a,0x1497,0x149d,0x149d,0x1488,
+0x148b,0x173d,0x1740,0x1740,0x1740,0x1584,0x1b3,0x1b3,0x148e,0x148e,0x148e,0x148e,0x148e,0x148e,0x148e,0x148e,
+0x148e,0x148e,0x1581,0x1746,0x1749,0x1743,0x174c,0x174c,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,0x14a3,
+0x14a3,0x1b6,0x1b6,0x1b6,0x1b6,0x1b6,0x1b6,0x1b6,0x14a0,0x14a0,0x14a0,0x14a0,0x14a0,0x14a0,0x14a0,0x14a0,
+0x14a0,0x14a0,0x1b6,0x1b6,0x1b6,0x1b6,0x1b6,0x1b6,0x14a6,0x14a6,0x14a6,0x14a6,0x14a6,0x14a6,0x14a6,0x14a6,
+0x1b9,0x1b9,0x1b9,0x1b9,0x1b9,0x1b9,0x1b9,0x1b9,0x12fc,0x12f9,0x12fc,0x12db,0x12f9,0x12ff,0x12ff,0x1302,
+0x12ff,0x1302,0x1305,0x12f9,0x1302,0x1302,0x12f9,0x12f9,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,
+0x14b8,0x14b8,0x14b8,0x14a9,0x14b2,0x14a9,0x14b2,0x14b2,0x14a9,0x14a9,0x14a9,0x14a9,0x14a9,0x14a9,0x14b5,0x14ac,
+0x1bc,0x1bc,0x1bc,0x1bc,0x1bc,0x1bc,0x1bc,0x1bc,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,
+0x158a,0x158a,0x158a,0x158a,0x158a,0x158a,0x1bf,0x1bf,0x1587,0x1587,0x1587,0x1587,0x1587,0x158d,0x1bf,0x1bf,
+0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,0x1bf,0x16f2,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,
+0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,0x16e9,
+0x16e9,0x16e9,0x16e9,0x16e9,0x1c5,0x1c5,0x1c5,0x1c5,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,
+0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,
+0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x1c8,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,
+0x15a5,0x15a5,0x15a5,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,
+0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x15a5,0x15a5,0x15a5,0x15a5,
+0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x1cb,0x1cb,0x15a2,0x159c,0x159f,0x15a8,0x15ab,0x15ab,0x15ab,0x15ab,
+0x15ab,0x15ab,0x15ab,0x15ab,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1593,0x1593,0x1593,0x1593,
+0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x15ae,0x15ae,0x15ae,0x15ae,
+0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,
+0x15ae,0x1962,0x1962,0x1962,0x1962,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,
+0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,
+0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x174f,0x16f5,0x15b7,0x16fb,0x1d4,0x15c0,0x15c0,0x15c0,
+0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x1d4,0x1d4,0x15c0,0x15c0,0x1d4,0x1d4,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,
+0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x1d4,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,
+0x15c0,0x1d4,0x15c0,0x15c0,0x1d4,0x15c0,0x15c0,0x15c0,0x15c0,0x15c0,0x1d4,0x19ec,0x16f8,0x15c0,0x15b1,0x15b7,
+0x15b1,0x15b7,0x15b7,0x15b7,0x15b7,0x1d4,0x1d4,0x15b7,0x15b7,0x1d4,0x1d4,0x15ba,0x15ba,0x15bd,0x1d4,0x1d4,
+0x1752,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x15b1,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x15c3,0x15c0,0x15c0,
+0x15c0,0x15c0,0x15b7,0x15b7,0x1d4,0x1d4,0x15b4,0x15b4,0x15b4,0x15b4,0x15b4,0x15b4,0x15b4,0x1d4,0x1d4,0x1d4,
+0x15b4,0x15b4,0x15b4,0x15b4,0x15b4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,
 0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,
-0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1437,0x1434,0x142e,0x142e,0x1434,0x1434,
-0x143d,0x143d,0x1437,0x143a,0x143a,0x1434,0x1431,0x1ad,0x1ad,0x1ad,0x1ad,0x1ad,0x1ad,0x1ad,0x1ad,0x1ad,
-0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,
-0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1440,0x1b0,0x1b0,0x1b0,0x1b0,0x170a,0x170a,0x1440,0x1440,
-0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,
-0x1b0,0x1b0,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,
-0x144c,0x144c,0x144c,0x144c,0x144c,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,
-0x144c,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,
-0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,0x1449,
-0x1449,0x1449,0x1449,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,0x1b3,
-0x1b3,0x1b3,0x1b3,0x1446,0x1446,0x1446,0x1446,0x144f,0x144f,0x144f,0x144f,0x144f,0x144f,0x144f,0x144f,0x144f,
-0x144f,0x144f,0x144f,0x144f,0x1461,0x1464,0x1467,0x1467,0x1464,0x146a,0x146a,0x1455,0x1458,0x1710,0x170d,0x170d,
-0x170d,0x1554,0x1b6,0x1b6,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x1551,0x1716,
-0x1719,0x1713,0x171c,0x171c,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1470,0x1b9,0x1b9,0x1b9,
-0x1b9,0x1b9,0x1b9,0x1b9,0x146d,0x146d,0x146d,0x146d,0x146d,0x146d,0x146d,0x146d,0x146d,0x146d,0x1b9,0x1b9,
-0x1b9,0x1b9,0x1b9,0x1b9,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1473,0x1bc,0x1bc,0x1bc,0x1bc,
-0x1bc,0x1bc,0x1bc,0x1bc,0x12c3,0x12c0,0x12c3,0x12ab,0x12c0,0x12c0,0x12c0,0x12c6,0x12c0,0x12c6,0x12c9,0x12c0,
-0x12c6,0x12c6,0x12c0,0x12c0,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1476,
-0x147f,0x1476,0x147f,0x147f,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1482,0x1479,0x1bf,0x1bf,0x1bf,0x1bf,
-0x1bf,0x1bf,0x1bf,0x1bf,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,0x155a,
-0x155a,0x155a,0x1c2,0x1c2,0x1557,0x1557,0x1557,0x1557,0x1557,0x155d,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,0x1c2,
-0x1c2,0x1c2,0x1c2,0x1c2,0x16c2,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,
-0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,0x16b9,
-0x1c8,0x1c8,0x1c8,0x1c8,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,
-0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,0x1cb,
-0x1cb,0x1cb,0x1cb,0x1cb,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1ce,
-0x1ce,0x1ce,0x1ce,0x1ce,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1ce,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1ce,0x1ce,0x1572,0x156c,0x156f,0x1578,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,
-0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1d1,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,
-0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,
-0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x1d4,0x1d4,0x1d4,
-0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,
-0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,0x1d4,
-0x171f,0x16c5,0x1587,0x16cb,0x1d7,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1d7,0x1d7,0x1590,
-0x1590,0x1d7,0x1d7,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,
-0x1590,0x1d7,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1590,0x1d7,0x1590,0x1590,0x1d7,0x1590,0x1590,0x1590,
-0x1590,0x1590,0x1d7,0x1d7,0x16c8,0x1590,0x1581,0x1587,0x1581,0x1587,0x1587,0x1587,0x1587,0x1d7,0x1d7,0x1587,
-0x1587,0x1d7,0x1d7,0x158a,0x158a,0x158d,0x1d7,0x1d7,0x1722,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1581,
-0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1593,0x1590,0x1590,0x1590,0x1590,0x1587,0x1587,0x1d7,0x1d7,0x1584,0x1584,
-0x1584,0x1584,0x1584,0x1584,0x1584,0x1d7,0x1d7,0x1d7,0x1584,0x1584,0x1584,0x1584,0x1584,0x1d7,0x1d7,0x1d7,
-0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x1d7,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,
-0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x1da,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,
-0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a8,0x15a2,0x15a2,0x15a2,0x1596,0x1596,0x1596,0x15a2,0x15a2,
-0x1596,0x15a5,0x1599,0x1596,0x15ab,0x15ab,0x159f,0x15ab,0x15ab,0x159c,0x17b5,0x1da,0x15ba,0x15ba,0x15ba,0x15ae,
-0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15b1,0x15b4,0x1dd,0x1dd,0x1dd,0x1dd,0x1dd,0x15b7,0x15b7,0x15b7,0x15b7,
-0x15b7,0x15b7,0x15b7,0x15b7,0x15b7,0x15b7,0x1dd,0x1dd,0x1dd,0x1dd,0x1dd,0x1dd,0x1725,0x1725,0x1725,0x1725,
-0x15c6,0x15c3,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x174f,0x174f,0x174f,0x174f,
-0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x15cc,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,
-0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,0x15d8,0x15d8,0x15d8,0x15d8,
-0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15cf,
-0x15d2,0x15d5,0x15d8,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,0x15e7,0x15e7,0x15e7,0x15e7,
-0x15e7,0x15db,0x15db,0x1e9,0x1e9,0x1e9,0x1e9,0x15de,0x15de,0x15de,0x15de,0x15de,0x15e4,0x15e4,0x15e4,0x15e4,
-0x15e4,0x15e4,0x15e1,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,0x15f0,0x15f0,0x15f0,0x15f0,
-0x15f0,0x1ec,0x1ec,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ea,0x15ea,0x15ea,0x15ea,
-0x15ea,0x15ea,0x15ea,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x15f3,0x1605,0x1605,0x15f9,
-0x1602,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x15fc,0x15fc,0x15fc,0x15fc,
-0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x1ef,0x160b,0x160b,0x160b,0x160b,
-0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,
-0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x160b,0x1f2,0x1617,0x1617,0x1617,0x1617,
-0x1617,0x1611,0x161a,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1614,0x1614,0x1614,0x1614,
-0x1614,0x1614,0x1614,0x1614,0x1614,0x1614,0x1617,0x1617,0x1617,0x1617,0x1617,0x1f5,0x1620,0x1620,0x1620,0x1620,
-0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,
-0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1f8,0x162c,0x162c,0x162c,0x162c,
-0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,
-0x162c,0x162c,0x1629,0x1629,0x1629,0x1629,0x1629,0x1fb,0x1fb,0x1fb,0x1fb,0x1fb,0x1644,0x1644,0x1647,0x1647,
-0x164a,0x163b,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1641,0x1641,0x1641,0x1641,
-0x1641,0x1641,0x1641,0x1641,0x1641,0x1641,0x1fe,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x1fe,0x1644,
-0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,
-0x1644,0x1644,0x1644,0x1644,0x1fe,0x1fe,0x1fe,0x1fe,0x1fe,0x1644,0x1644,0x1644,0x1653,0x1653,0x1653,0x1653,
-0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,
-0x1653,0x1653,0x1653,0x1653,0x1653,0x201,0x201,0x201,0x201,0x201,0x201,0x201,0x165c,0x165c,0x165c,0x165c,
-0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x204,0x204,
-0x204,0x204,0x204,0x204,0x204,0x1659,0x1659,0x1659,0x1659,0x204,0x204,0x204,0x1677,0x1677,0x1677,0x1677,
-0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x165f,0x1671,0x1671,0x165f,0x165f,
-0x165f,0x165f,0x20a,0x20a,0x1671,0x1671,0x1674,0x1674,0x165f,0x165f,0x1671,0x1665,0x1662,0x1668,0x167a,0x167a,
-0x166b,0x166b,0x166e,0x166e,0x166e,0x167a,0x172e,0x172e,0x172e,0x172e,0x172e,0x172e,0x172e,0x172e,0x172e,0x172e,
-0x172e,0x172e,0x172e,0x172e,0x172b,0x172b,0x172b,0x172b,0x1728,0x1728,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,
-0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,
-0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20d,0x167d,0x167d,0x167d,
-0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,0x167d,
-0x167d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x1680,0x1680,0x1680,0x1680,
-0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x210,0x210,0x210,0x210,0x1680,0x1680,0x1680,0x1680,
-0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x210,0x210,0x210,0x210,
-0x210,0x210,0x210,0x210,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x210,0x210,
-0x210,0x210,0x210,0x210,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x210,0x210,0x210,0x210,
-0x210,0x210,0x210,0x210,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,
-0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,
-0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,
-0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x1683,0x1692,0x1689,0x1686,0x1698,0x1698,0x168c,0x1698,
-0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x168f,0x168f,0x168f,0x168f,0x168f,0x168f,0x168f,0x168f,
-0x168f,0x168f,0x213,0x213,0x213,0x213,0x213,0x213,0x169e,0x169e,0x169e,0x169e,0x169e,0x169e,0x169e,0x169e,
-0x169e,0x169e,0x169b,0x169b,0x169b,0x169b,0x169b,0x169b,0x169b,0x169b,0x169b,0x216,0x216,0x216,0x216,0x216,
-0x216,0x216,0x216,0x216,0x216,0x216,0x216,0x16a4,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,
-0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,0x1740,
-0x1740,0x1740,0x219,0x219,0x219,0x1731,0x1731,0x1731,0x173d,0x173d,0x1731,0x1731,0x1731,0x1731,0x173d,0x1731,
-0x1731,0x1731,0x1731,0x1734,0x219,0x219,0x219,0x219,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,
-0x173a,0x173a,0x1737,0x1737,0x1743,0x1743,0x1743,0x1737,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x21c,
-0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,
-0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,0x21c,
-0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,0x1758,
-0x1758,0x1758,0x1758,0x222,0x1758,0x1758,0x222,0x222,0x222,0x222,0x222,0x1755,0x1755,0x1755,0x1755,0x1755,
-0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x225,0x175b,0x225,0x175b,0x175b,0x175b,0x175b,0x225,0x175b,
-0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x225,0x175b,
-0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175b,0x175e,0x225,0x225,0x225,0x225,0x225,0x225,
-0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,
-0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,
-0x1767,0x1767,0x1767,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,
-0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,
-0x1764,0x1764,0x1764,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x1761,0x1761,0x1761,0x1761,0x1761,0x1761,
-0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x22b,0x22b,0x22b,0x22b,
-0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x178b,0x1839,0x1839,0x1839,0x1839,0x1836,0x1839,0x18d5,
-0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1839,0x1836,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,
-0x1839,0x18d5,0x18d5,0x1839,0x1839,0x1839,0x1839,0x1839,0x1839,0x1839,0x1836,0x1833,0x1836,0x1839,0x1839,0x22b,
-0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1833,0x1836,0x1836,0x1836,0x1836,0x1836,0x18d2,0x22b,0x22b,0x22b,
-0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x18d2,
-0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x22b,0x22b,0x22b,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
-0x1788,0x1788,0x1788,0x1788,0x1788,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,0x1836,
-0x1836,0x1836,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x1788,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x18d2,0x18d5,0x18d5,0x18d5,0x18d5,0x18d5,0x18d5,0x18d5,
-0x18d5,0x18d5,0x18d5,0x18d5,0x18d5,0x18d5,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x18d2,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
-0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x176d,0x176d,0x176d,0x176d,0x176a,0x176d,0x176d,0x1770,
-0x1773,0x1770,0x1770,0x176d,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,0x22e,
-0x22e,0x22e,0x22e,0x176a,0x176a,0x176a,0x176a,0x176a,0x17c7,0x17c7,0x17c7,0x17c7,0x17be,0x17be,0x17be,0x17b8,
-0x17bb,0x17bb,0x17bb,0x231,0x231,0x231,0x231,0x231,0x17c4,0x17c4,0x17c4,0x17c4,0x17c4,0x17c4,0x17c4,0x17c4,
-0x17c4,0x17c4,0x231,0x231,0x231,0x231,0x17c1,0x17c1,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,
-0x17e2,0x234,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,
-0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17e2,0x17df,0x17cd,0x17cd,0x17cd,0x17cd,
-0x17cd,0x17cd,0x17cd,0x234,0x17cd,0x17cd,0x17cd,0x17cd,0x17cd,0x17cd,0x17df,0x17d0,0x17e2,0x17e5,0x17e5,0x17d9,
-0x17d6,0x17d6,0x234,0x234,0x234,0x234,0x234,0x234,0x234,0x234,0x234,0x234,0x17dc,0x17dc,0x17dc,0x17dc,
-0x17dc,0x17dc,0x17dc,0x17dc,0x17dc,0x17dc,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,
-0x17d3,0x17d3,0x17d3,0x17d3,0x17d3,0x234,0x234,0x234,0x17f1,0x17f4,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,
-0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x23a,
-0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,
-0x17eb,0x23a,0x23a,0x17eb,0x17eb,0x17eb,0x17eb,0x17eb,0x183c,0x18d8,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,
-0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,
-0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,
-0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x240,0x240,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,
-0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x240,0x17f7,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,0x17ee,
-0x17ee,0x17f7,0x17ee,0x17ee,0x17f7,0x17ee,0x17ee,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,
-0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x243,0x243,0x243,
+0x15d8,0x15d8,0x1d7,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,0x15d8,
+0x15d2,0x15d2,0x15d2,0x15c6,0x15c6,0x15c6,0x15d2,0x15d2,0x15c6,0x15d5,0x15c9,0x15c6,0x15db,0x15db,0x15cf,0x15db,
+0x15db,0x15cc,0x17e5,0x1d7,0x15ea,0x15ea,0x15ea,0x15de,0x15de,0x15de,0x15de,0x15de,0x15de,0x15e1,0x15e4,0x1da,
+0x1da,0x1da,0x1da,0x1da,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x1da,0x1da,
+0x1da,0x1da,0x1da,0x1da,0x1755,0x1755,0x1755,0x1755,0x15f6,0x15f3,0x1dd,0x1dd,0x1dd,0x1dd,0x1dd,0x1dd,
+0x1dd,0x1dd,0x1dd,0x1dd,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,
+0x177f,0x177f,0x177f,0x177f,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,
+0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,
+0x1e0,0x1e0,0x1e0,0x1e0,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,
+0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,
+0x1e0,0x1e0,0x1e0,0x1e0,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x1e0,0x1e0,0x1e0,0x1e0,
+0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,0x1e0,
+0x1e0,0x1e0,0x1e0,0x1e0,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,
+0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x1608,0x15ff,0x1602,0x1605,0x1608,0x1e3,0x1e3,0x1e3,0x1e3,0x1e3,
+0x1e3,0x1e3,0x1e3,0x1e3,0x1617,0x1617,0x1617,0x1617,0x1617,0x160b,0x160b,0x1e6,0x1e6,0x1e6,0x1e6,0x160e,
+0x160e,0x160e,0x160e,0x160e,0x1614,0x1614,0x1614,0x1614,0x1614,0x1614,0x1611,0x1e6,0x1e6,0x1e6,0x1e6,0x1e6,
+0x1e6,0x1e6,0x1e6,0x1e6,0x1620,0x1620,0x1620,0x1620,0x1620,0x1e9,0x1e9,0x161d,0x161d,0x161d,0x161d,0x161d,
+0x161d,0x161d,0x161d,0x161d,0x161a,0x161a,0x161a,0x161a,0x161a,0x161a,0x161a,0x1e9,0x1e9,0x1e9,0x1e9,0x1e9,
+0x1e9,0x1e9,0x1e9,0x1e9,0x1623,0x1635,0x1635,0x1629,0x1632,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,0x1ec,
+0x1ec,0x1ec,0x1ec,0x1ec,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x162c,0x1ec,0x1ec,
+0x1ec,0x1ec,0x1ec,0x1ec,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,
+0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,
+0x163b,0x163b,0x163b,0x1ef,0x1647,0x1647,0x1647,0x1647,0x1647,0x1641,0x164a,0x1647,0x1647,0x1647,0x1647,0x1647,
+0x1647,0x1647,0x1647,0x1647,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1647,0x1647,
+0x1647,0x1647,0x1647,0x1f2,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,
+0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,
+0x1650,0x1650,0x1650,0x1f5,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,
+0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x165c,0x1659,0x1659,0x1659,0x1659,0x1659,0x1f8,
+0x1f8,0x1f8,0x1f8,0x1f8,0x1674,0x1674,0x1677,0x1677,0x167a,0x166b,0x1fb,0x1fb,0x1fb,0x1fb,0x1fb,0x1fb,
+0x1fb,0x1fb,0x1fb,0x1fb,0x1671,0x1671,0x1671,0x1671,0x1671,0x1671,0x1671,0x1671,0x1671,0x1671,0x1fb,0x166b,
+0x166b,0x166b,0x166b,0x166b,0x166b,0x166b,0x1fb,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,
+0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1fb,0x1fb,0x1fb,0x1fb,
+0x1fb,0x1674,0x1674,0x1674,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,
+0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1fe,0x1fe,0x1fe,
+0x1fe,0x1fe,0x1fe,0x1fe,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,
+0x168c,0x168c,0x168c,0x168c,0x168c,0x168c,0x201,0x201,0x201,0x201,0x201,0x201,0x201,0x1689,0x1689,0x1689,
+0x1689,0x201,0x201,0x201,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,
+0x16a7,0x16a7,0x16a7,0x168f,0x16a1,0x16a1,0x168f,0x168f,0x168f,0x168f,0x207,0x207,0x16a1,0x16a1,0x16a4,0x16a4,
+0x168f,0x168f,0x16a1,0x1695,0x1692,0x1698,0x16aa,0x16aa,0x169b,0x169b,0x169e,0x169e,0x169e,0x16aa,0x175e,0x175e,
+0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175e,0x175b,0x175b,0x175b,0x175b,
+0x1758,0x1758,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,
+0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,0x207,
+0x207,0x207,0x207,0x207,0x20a,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,
+0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x16ad,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,0x20a,
+0x20a,0x20a,0x20a,0x20a,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,
+0x20d,0x20d,0x20d,0x20d,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x20d,0x20d,
+0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,
+0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,0x20d,
+0x16b3,0x16c2,0x16b9,0x16b6,0x16c8,0x16c8,0x16bc,0x16c8,0x210,0x210,0x210,0x210,0x210,0x210,0x210,0x210,
+0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x16bf,0x210,0x210,0x210,0x210,0x210,0x210,
+0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16ce,0x16cb,0x16cb,0x16cb,0x16cb,0x16cb,0x16cb,
+0x16cb,0x16cb,0x16cb,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x213,0x16d4,
+0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,
+0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1770,0x1965,0x216,0x216,0x1761,0x1761,0x1761,
+0x176d,0x176d,0x1761,0x1761,0x1761,0x1761,0x176d,0x1761,0x1761,0x1761,0x1761,0x1764,0x216,0x216,0x216,0x216,
+0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x1767,0x1767,0x1773,0x1773,0x1773,0x1767,
+0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,
+0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,
+0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x219,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,
+0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x1788,0x21f,0x1788,0x1788,0x21f,0x21f,
+0x21f,0x21f,0x21f,0x1785,0x1785,0x1785,0x1785,0x1785,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x222,
+0x178b,0x222,0x178b,0x178b,0x178b,0x178b,0x222,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,
+0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x222,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,0x178b,
+0x178b,0x178e,0x222,0x222,0x222,0x222,0x222,0x222,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,
+0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,
+0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x225,0x225,0x225,0x225,0x225,
+0x225,0x225,0x225,0x225,0x225,0x225,0x225,0x225,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,
+0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x225,0x225,0x225,0x225,0x225,
+0x225,0x225,0x1791,0x1791,0x1791,0x1791,0x1791,0x1791,0x189f,0x189f,0x189f,0x189f,0x189f,0x189f,0x189f,0x189f,
+0x189f,0x189f,0x189f,0x189f,0x228,0x228,0x228,0x228,0x17b8,0x17b8,0x17b8,0x17b8,0x17b8,0x17b8,0x17b8,0x17b8,
+0x17bb,0x1869,0x1869,0x1869,0x1869,0x1866,0x1869,0x1905,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1869,0x1866,
+0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1869,0x1905,0x1905,0x1869,0x1869,0x1869,0x1869,0x1869,
+0x1869,0x1869,0x1866,0x1863,0x1866,0x1869,0x1869,0x228,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,
+0x1902,0x1902,0x1902,0x1902,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x228,0x228,0x19e0,0x19e0,0x19e0,0x19e0,0x228,
+0x228,0x228,0x19e0,0x228,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x228,0x228,0x228,0x228,0x228,
+0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x19e3,0x19e3,0x19e3,0x19e3,0x19e0,0x19e6,0x19e6,0x19e0,
+0x19e6,0x19e6,0x228,0x228,0x228,0x228,0x228,0x228,0x17b8,0x19e0,0x19e0,0x228,0x228,0x228,0x228,0x228,
+0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x228,0x1902,0x1905,0x1905,0x1905,0x1905,0x1905,0x1905,0x1905,
+0x1905,0x1905,0x1905,0x1905,0x1905,0x1905,0x1902,0x1902,0x179d,0x179d,0x179d,0x179d,0x179a,0x179d,0x179d,0x17a0,
+0x17a3,0x17a0,0x17a0,0x179d,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,0x22b,
+0x22b,0x22b,0x22b,0x179a,0x179a,0x179a,0x179a,0x179a,0x17f7,0x17f7,0x17f7,0x17f7,0x17ee,0x17ee,0x17ee,0x17e8,
+0x17eb,0x17eb,0x17eb,0x22e,0x22e,0x22e,0x22e,0x22e,0x17f4,0x17f4,0x17f4,0x17f4,0x17f4,0x17f4,0x17f4,0x17f4,
+0x17f4,0x17f4,0x22e,0x22e,0x22e,0x22e,0x17f1,0x17f1,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
+0x1812,0x231,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,
+0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x180f,0x17fd,0x17fd,0x17fd,0x17fd,
+0x17fd,0x17fd,0x17fd,0x231,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x17fd,0x180f,0x1800,0x1812,0x1815,0x1815,0x1809,
+0x1806,0x1806,0x231,0x231,0x231,0x231,0x231,0x231,0x231,0x231,0x231,0x231,0x180c,0x180c,0x180c,0x180c,
+0x180c,0x180c,0x180c,0x180c,0x180c,0x180c,0x1803,0x1803,0x1803,0x1803,0x1803,0x1803,0x1803,0x1803,0x1803,0x1803,
+0x1803,0x1803,0x1803,0x1803,0x1803,0x231,0x231,0x231,0x1821,0x1824,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,
+0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,
+0x1818,0x234,0x234,0x234,0x234,0x234,0x234,0x234,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,
+0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x237,
+0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,0x181b,
+0x181b,0x237,0x237,0x181b,0x181b,0x181b,0x181b,0x181b,0x186c,0x1908,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,
+0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,
+0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x23a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,
+0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x182a,0x23d,0x23d,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,
+0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x23d,0x1827,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,
+0x181e,0x1827,0x181e,0x181e,0x1827,0x181e,0x181e,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,0x23d,
+0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x182d,0x240,0x240,0x240,
+0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,0x240,
+0x1845,0x1845,0x1836,0x1830,0x1830,0x1845,0x1833,0x1848,0x1848,0x1848,0x1848,0x184b,0x184b,0x183f,0x183c,0x1839,
+0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x243,0x183f,0x243,0x1839,0x1968,0x243,
 0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,
-0x1815,0x1815,0x1806,0x1800,0x1800,0x1815,0x1803,0x1818,0x1818,0x1818,0x1818,0x181b,0x181b,0x180f,0x180c,0x1809,
-0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x1812,0x246,0x180f,0x246,0x1809,0x246,0x246,
-0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,
-0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,0x246,
-0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,0x1821,
-0x1821,0x1821,0x1821,0x1821,0x249,0x249,0x249,0x249,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,
-0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,0x181e,
-0x181e,0x181e,0x181e,0x181e,0x249,0x249,0x249,0x249,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,
-0x183f,0x183f,0x183f,0x183f,0x183f,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,
-0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,
-0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x24f,0x24f,0x24f,0x24f,0x24f,
-0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x24f,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,
-0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,
-0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x18de,0x252,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x255,
-0x187e,0x187e,0x255,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,
-0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x187e,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x255,
-0x255,0x255,0x1872,0x255,0x1872,0x1872,0x255,0x1872,0x1872,0x1872,0x1875,0x1872,0x1878,0x1878,0x1881,0x1872,
-0x255,0x255,0x255,0x255,0x255,0x255,0x255,0x255,0x187b,0x187b,0x187b,0x187b,0x187b,0x187b,0x187b,0x187b,
-0x187b,0x187b,0x255,0x255,0x255,0x255,0x255,0x255,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0x18e1,0x18e1,0x18e1,0x18e1,0x258,0x258,0x258,0x258,0x1899,0x1899,0x1899,0x1899,0x25b,0x25b,0x189c,0x189c,
-0x189c,0x189c,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1896,
-0x1887,0x188a,0x188d,0x189f,0x189f,0x25b,0x1890,0x1890,0x18ae,0x18b1,0x18c0,0x18c0,0x18b1,0x18b4,0x18ae,0x18ab,
-0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x1899,0x1884,0x1884,0x1884,0x1884,0x1884,0x1884,0x1896,
-0x1896,0x1884,0x1884,0x1884,0x1899,0x1899,0x1899,0x1899,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,
-0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,
-0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x18db,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,
-0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,
-0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,0x264,
-0x264,0x264,0x264,0x264,0x264,0x264,0x933,0x933,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,
-0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0x267,0x267,
-0x267,0x267,0x267,0x267,0x267,0x267,0x267,0x267,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,
-0x18c6,0x18c6,0x18c6,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,
-0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,
-0xc4b,0xc4b,0xc4b,0x128d,0x128d,0x128d,0x26d,0x26d,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,
-0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,
-0xe7c,0xe7c,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,
-0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,
-0x26d,0x26d,0x26d,0x26d,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,
-0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0x270,0x270,0x270,0x270,0x270,
-0x270,0x270,0x270,0x270,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,
-0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,
-0xb5e,0xb5e,0x273,0x273,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,
-0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x276,0x276,0x276,0x276,0x276,0x276,0x276,
-0x276,0x276,0x276,0x276,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,
-0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,
-0x13bc,0x13bc,0x279,0x279,0x1785,0x1785,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,
-0x27c,0x27c,0x27c,0x27c,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,
-0x18db,0x18db,0x18db,0x18db,0x1101,0x378,0x378,0x384,0xc8d,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
-0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,
-0x387,0x387,0x387,0x387,0x384,0x378,0x378,0x378,0x378,0x378,0x378,0x378,0x378,0x384,0x384,0x384,
-0x384,0x37e,0x1104,0x12db,0x387,0x900,0x903,0x37b,0x37b,0x1101,0x12d8,0x12d8,0x38a,0x38a,0x38a,0x38a,
-0x38a,0x38a,0x38a,0x38a,0x387,0x387,0x378,0x378,0x88b,0x88e,0x91b,0x91b,0x91b,0x91b,0x91b,0x91b,
-0x91b,0x91b,0x91b,0x91b,0x381,0xf63,0xf60,0x12de,0x12de,0x12de,0x12de,0x12de,0x14af,0x1107,0x1107,0xeb5,
-0xeb5,0xd80,0xeb5,0xeb5,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x387,0x38a,0x387,0x387,
-0x387,0x387,0x387,0x387,0x387,0x38a,0x387,0x387,0x38a,0x387,0x387,0x387,0x387,0x387,0x12d8,0x12db,
-0x37b,0x387,0x384,0x384,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x12e4,0x429,0x429,
-0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x429,0x12e4,0x1857,
-0x1857,0xf81,0x41a,0x423,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,
-0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0x465,0xb79,0xb79,0xd8c,0xd8c,0x891,
-0xd8f,0x13ce,0x13ce,0x13ce,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,
-0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,0x468,
-0x468,0x468,0x468,0x468,0x46e,0x46e,0x46e,0x111c,0x111c,0x111c,0x111c,0x111c,0x46b,0x46b,0x46b,0x46b,
-0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,
-0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x46b,0x1119,0x1119,
-0x1119,0x1119,0x1119,0x1119,0x471,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,
-0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,
-0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x46e,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,
-0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,
-0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x474,0x474,0x474,0x474,0x477,0x975,
-0xfb1,0xfb1,0xfb4,0xfb1,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,
-0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0x47a,0x474,0xfb4,0xfb1,
-0xfb4,0xfb1,0xfb4,0xfb1,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x489,0x489,0x489,0x489,
-0x489,0x489,0x489,0x489,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x489,0x489,0x489,0x489,
-0x489,0x489,0x489,0x489,0x666,0x666,0x669,0x4a4,0x675,0x672,0x672,0x66f,0x4ce,0x4ce,0x48c,0x48c,
-0x48c,0x48c,0x48c,0xaa7,0x678,0x4b0,0x690,0x693,0x4c5,0x678,0x4b3,0x4b3,0x4a4,0x4bf,0x4bf,0x666,
-0x4cb,0x4c8,0x66c,0x49e,0x495,0x495,0x498,0x498,0x498,0x498,0x498,0x49b,0x498,0x498,0x498,0x48f,
-0x4d7,0x4d4,0x4d1,0x4d1,0x684,0x4b9,0x4b6,0x681,0x67e,0x67b,0x68d,0x4a7,0x68a,0x68a,0x4bc,0x4bf,
-0x687,0x687,0x4bc,0x4bf,0x4a1,0x4a4,0x4a4,0x4a4,0x4c2,0x4ad,0x4aa,0xb8e,0xaad,0xab0,0xaaa,0xaaa,
-0xaaa,0xaaa,0xb85,0xb85,0xb85,0xb85,0xb8b,0xcba,0xcb7,0xd9b,0xd9e,0xb88,0xd9e,0xd9e,0xd9e,0xd9e,
-0xd9b,0xd9e,0xd9e,0xb82,0x4fb,0x4fb,0x4fb,0x4fb,0x4fb,0x4fb,0x4fb,0x4f8,0x4fe,0x714,0x4fb,0x978,
-0x999,0xab3,0xab3,0xab3,0xb94,0xb94,0xda4,0xda4,0xda4,0xda4,0x1125,0x1128,0x1128,0x12f9,0x149d,0x14c7,
-0x14ca,0x14ca,0x16dd,0x185a,0x50a,0x50a,0x522,0x6a2,0x507,0x69f,0x50a,0x51f,0x507,0x6a2,0x519,0x522,
-0x522,0x522,0x519,0x519,0x522,0x522,0x522,0x6ab,0x507,0x522,0x6a5,0x507,0x516,0x522,0x522,0x522,
-0x522,0x522,0x507,0x507,0x50d,0x69f,0x6a8,0x507,0x522,0x507,0x6ae,0x507,0x522,0x510,0x528,0x6b1,
-0x522,0x522,0x513,0x519,0x522,0x522,0x525,0x522,0x519,0x51c,0x51c,0x51c,0x51c,0xabc,0xab9,0xcbd,
-0xdad,0xba9,0xbac,0xbac,0xba6,0xba3,0xba3,0xba3,0xba3,0xbac,0xba9,0xba9,0xba9,0xba9,0xba0,0xba3,
-0xdaa,0xec1,0xec4,0xfba,0x112b,0x112b,0x112b,0x6b7,0x6b4,0x52b,0x52e,0x52e,0x52e,0x52e,0x52e,0x6b4,
-0x6b7,0x6b7,0x6b4,0x52e,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,0x6bd,
-0x537,0x537,0x537,0x537,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x6ba,0x531,0x531,
-0x531,0x531,0x531,0x531,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53a,0x543,0x543,0x53d,
-0x53d,0x53d,0x540,0x53a,0x53d,0x53d,0x53a,0x53a,0x53a,0x53a,0x53d,0x53d,0x6c0,0x6c0,0x53a,0x53a,
-0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x540,0x540,0x540,
-0x53d,0x53d,0x6c3,0x53d,0x6c3,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53d,0x53a,0x53d,0x53a,0x53a,
-0x53a,0x53a,0x53a,0x53a,0x53d,0x53d,0x53a,0x6c0,0x53a,0x53a,0x53a,0xac2,0xac2,0xac2,0xac2,0xac2,
-0xac2,0xac2,0xac2,0xac2,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,0xbaf,
-0x6c9,0x546,0x6c9,0x6c9,0x549,0x546,0x546,0x6c9,0x6c9,0x549,0x546,0x6c9,0x549,0x546,0x546,0x6c9,
-0x546,0x6c9,0x555,0x552,0x546,0x6c9,0x546,0x546,0x546,0x546,0x6c9,0x546,0x546,0x6c9,0x6c9,0x6c9,
-0x6c9,0x546,0x546,0x6c9,0x549,0x6c9,0x549,0x6c9,0x6c9,0x6c9,0x6c9,0x6c9,0x6cf,0x54c,0x6c9,0x54c,
-0x54c,0x546,0x546,0x546,0x6c9,0x6c9,0x6c9,0x6c9,0x546,0x546,0x546,0x546,0x6c9,0x6c9,0x546,0x546,
-0x546,0x549,0x546,0x546,0x549,0x546,0x546,0x549,0x6c9,0x549,0x546,0x546,0x6c9,0x546,0x546,0x546,
-0x546,0x546,0x6c9,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,
-0x6cc,0x6c9,0x549,0x546,0x6c9,0x6c9,0x6c9,0x6c9,0x546,0x546,0x6c9,0x6c9,0x546,0x549,0x6cc,0x6cc,
-0x549,0x549,0x546,0x546,0x549,0x549,0x546,0x546,0x549,0x549,0x546,0x546,0x546,0x546,0x546,0x546,
-0x549,0x549,0x6c9,0x6c9,0x549,0x549,0x6c9,0x6c9,0x549,0x549,0x546,0x546,0x546,0x546,0x546,0x546,
-0x546,0x546,0x546,0x546,0x546,0x6c9,0x546,0x546,0x546,0x6c9,0x546,0x546,0x546,0x546,0x546,0x546,
-0x546,0x6c9,0x546,0x546,0x546,0x546,0x546,0x546,0x549,0x549,0x549,0x549,0x546,0x546,0x546,0x546,
-0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x6c9,0x546,0x546,0x546,0x546,
-0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,
-0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x546,0x549,0x549,0x549,0x549,
-0x546,0x546,0x546,0x546,0x546,0x546,0x549,0x549,0x549,0x549,0x546,0x54f,0x546,0x546,0xbb2,0xbb2,
-0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0xbb2,0x558,0xac5,0x558,0x558,
-0x558,0x558,0x558,0x558,0x564,0x561,0x564,0x561,0x558,0x558,0x558,0x558,0x558,0x558,0x6d2,0x558,
-0x558,0x558,0x558,0x558,0x558,0x558,0x7d7,0x7d7,0x558,0x558,0x558,0x558,0x55e,0x55e,0x558,0x558,
-0x558,0x558,0x558,0x558,0x55b,0x7dd,0x7da,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,
-0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,
-0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0x558,0xac5,0xbb8,0xac5,0xac5,0xac5,
-0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,
-0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,0x567,
-0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x56d,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,
-0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xc1e,0xd32,
-0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,
-0x6e4,0x6e4,0x6e4,0x6e4,0x570,0x573,0x573,0x573,0x573,0x573,0x573,0x573,0x573,0x573,0x573,0x573,
-0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x573,0x573,0x573,0x573,
-0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,
-0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,0x6e7,
-0x576,0x576,0x6e7,0x6e7,0x6e7,0x6e7,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,0xbbb,
-0x6ed,0x6ed,0x579,0x6ea,0x6ea,0x6ea,0x6ea,0x6ea,0x6ea,0x6ea,0x57c,0x57c,0x579,0x579,0x57f,0x57f,
-0x57f,0x57f,0x6ed,0x6ed,0x57f,0x57f,0x6f0,0x6ed,0x579,0x579,0x579,0x579,0x6ed,0x6ed,0x57f,0x57f,
-0x6f0,0x6ed,0x579,0x579,0x579,0x579,0x6ed,0x6ed,0x6ea,0x579,0x57f,0x6ed,0x579,0x579,0x6ea,0x6ed,
-0x6ed,0x6ed,0x57f,0x57f,0x579,0x579,0x579,0x579,0x579,0x579,0x579,0x579,0x579,0x579,0x579,0x579,
-0x579,0x579,0x6ed,0x6ea,0x6ed,0x6ea,0x579,0x57f,0x57f,0x57f,0x57f,0x57f,0x57f,0x579,0x579,0x6ea,
-0xacb,0xacb,0xacb,0xacb,0xacb,0xacb,0xacb,0xacb,0xbbe,0xbbe,0xbbe,0xbc1,0xbc1,0xc36,0xc36,0xbbe,
-0x58b,0x58b,0x58b,0x58b,0x588,0x6ff,0x6ff,0x582,0x582,0x6f3,0x582,0x582,0x582,0x582,0x6f9,0x6f3,
-0x582,0x588,0x582,0x582,0xd3b,0xd3b,0xbc4,0xbc4,0xdbc,0xace,0x585,0x585,0x6f6,0x58e,0x6f6,0x585,
-0x588,0x582,0x588,0x588,0x582,0x582,0x588,0x582,0x582,0x582,0x588,0x582,0x582,0x582,0x588,0x588,
-0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x588,0x58b,0x58b,0x585,0x582,0x582,0x582,0x582,
-0x705,0x582,0x705,0x582,0x582,0x582,0x582,0x582,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,0x7e0,
-0x7e0,0x7e0,0x7e0,0x7e0,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,0x582,
-0x702,0x6ff,0x591,0x702,0x6f3,0x6f9,0x588,0x6f3,0x6fc,0x6f3,0x6f3,0x582,0x6f3,0x6ff,0x591,0x6ff,
-0xace,0xace,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbca,0xbc7,0xbc7,0xdb3,0xe73,
-0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,0x594,
-0x594,0x594,0x594,0x594,0x597,0x1383,0x1383,0x1383,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,
-0x14d3,0x59d,0x5a9,0x59d,0x59d,0x1383,0x597,0x597,0x5ac,0x5a9,0x1386,0x1386,0x5af,0x5af,0x597,0x5a3,
-0x597,0x597,0x5a3,0x597,0x5a3,0x597,0x5a3,0x597,0x597,0x597,0x597,0x597,0x597,0x5a3,0x597,0x597,
-0x597,0x597,0x597,0x597,0x1383,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x5a3,
-0x5a3,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x70b,0x597,0x597,0x597,0x597,0x597,0x597,
-0x5a3,0x597,0x597,0x5a3,0x597,0x597,0x597,0x597,0x1383,0x597,0x1383,0x597,0x597,0x597,0x597,0x1383,
-0x1383,0x1383,0x597,0x1287,0x597,0x597,0x597,0x5a0,0x5a0,0x5a0,0x5a0,0x1305,0x1305,0x597,0x59a,0x5a6,
-0x5ac,0x597,0x597,0x597,0xbd0,0xbcd,0xbd0,0xbcd,0xbd0,0xbcd,0xbd0,0xbcd,0xbd0,0xbcd,0xbd0,0xbcd,
-0xbd0,0xbcd,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x597,0x5a3,0x597,0x597,
-0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x1383,0x597,0x597,0x597,
-0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x1383,0x5d0,0x5d0,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,
-0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d0,0x5d6,0x5c7,0x5ca,0x5d6,0x5d6,0x5d6,0x5d6,
-0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,
-0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5cd,0x5cd,0x5cd,0x5cd,0x5cd,0x5cd,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,
-0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,
-0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,
-0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,
-0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,
-0x5d3,0x5d9,0x5d6,0x5d0,0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,0x1308,0x1308,0x1308,0x1308,0x1308,0x1308,
-0x1308,0x1308,0x1308,0x1308,0x1308,0x1308,0x1308,0x1308,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d3,0x5d9,
-0x5d3,0x5d9,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,0x5d6,0x5d0,
-0x5d3,0x5d6,0x5d0,0x5d3,0x5d6,0x5d0,0x5d3,0x5d9,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,
-0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,
-0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d3,0x5d0,0x5d3,0x5d0,0x5d3,0x5d0,0x5d0,
-0x5d3,0x5d0,0x5d0,0x5d3,0x5d0,0x5d3,0x5d0,0x5d0,0x5d3,0x5d0,0x5d3,0x5d3,0x5d0,0x5d0,0x5d0,0x5d3,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,
-0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d3,0x5d0,0x5d0,
-0x5d3,0x5d0,0x5d3,0x5d0,0x5d0,0x5d0,0x5d0,0x5d0,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,
-0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,
-0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d3,0x5d9,0x5d6,0x5d6,0x5d6,0x5d6,
-0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,
-0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d9,0x5d9,0x5d9,0x5d9,
-0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,0x5d9,
-0x5d9,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5d6,0x5dc,0x5dc,0x5dc,0x5dc,
-0xfc6,0xfc6,0xfc6,0x14d6,0x14d6,0x14d6,0x14d6,0x14d6,0x14d6,0x14d6,0x16e3,0x16e3,0x83d,0x843,0x843,0x84f,
-0x84f,0x840,0x837,0x840,0x837,0x840,0x837,0x840,0x837,0x840,0x837,0x840,0x5eb,0x5eb,0x5e5,0x5eb,
-0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,
-0x5e5,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5eb,
-0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,
-0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,
-0x5ee,0x5eb,0x5e5,0x5e8,0x5ee,0x5eb,0x5e5,0x5e8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,
-0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d8,0x6d5,0x6d5,0x6d5,0x6d5,
-0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,
-0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6d5,0x6de,0x6de,
-0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6e1,0x6de,0x6de,0x6de,0x6de,0x6de,
-0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,
-0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,
-0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,
-0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x6e4,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,
-0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,
-0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0x70e,0xc24,0x8a3,0x89d,0x89a,0x8a0,0x897,0x723,0x726,
-0x726,0x726,0x726,0x726,0x726,0x726,0x726,0x726,0x8a9,0x723,0x723,0x723,0x723,0x723,0x723,0x723,
-0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,
-0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x723,0x8a6,0x8a6,0x729,0x8b8,0x8bb,0x8c1,
-0x7e3,0x7ef,0x8d6,0x7ec,0x8af,0x8ac,0x8af,0x8ac,0x8b5,0x8b2,0x8b5,0x8b2,0x8af,0x8ac,0x7e9,0x8c1,
-0x8af,0x8ac,0x8af,0x8ac,0x8af,0x8ac,0x8af,0x8ac,0x8c4,0x8cd,0x8ca,0x8ca,0x72f,0x76b,0x76b,0x76b,
-0x76b,0x76b,0x76b,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x765,
-0x765,0x765,0x765,0x765,0x765,0x765,0x765,0x732,0x74d,0x72c,0x753,0x756,0x750,0x768,0x768,0x768,
-0x768,0x768,0x768,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x762,
-0x762,0x762,0x762,0x762,0x762,0x762,0x762,0x732,0x74d,0x72c,0x74d,0xc27,0x7d1,0x7d1,0x7d1,0x7d1,
-0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,
-0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x7d1,0x1281,0x1281,
-0x1281,0x1281,0x1281,0x7d4,0x7e9,0x7ec,0x7ec,0x7ec,0x7ec,0x7ec,0x7ec,0x7ec,0x7ec,0x7ec,0x90c,0x90c,
-0x90c,0x90c,0x7f2,0x7f2,0x8c7,0x8d3,0x8d3,0x8d3,0x8d3,0x8d0,0x7e6,0x8be,0xaf2,0xaf2,0xaf2,0xc39,
-0xc57,0xc54,0xb0d,0x894,0x7f8,0x7f5,0x7f8,0x7fb,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f8,0x7f5,0x7f5,
-0x7f5,0x7f5,0x7f5,0x7f5,0x7f8,0x7f8,0x7f5,0x7f8,0x7f8,0x7f5,0x7f8,0x7f8,0x7f5,0x7f8,0x7f8,0x7f5,
-0x7f8,0x7f8,0x7f5,0x7f5,0xc5a,0x80a,0x804,0x80a,0x804,0x80a,0x804,0x80a,0x804,0x80a,0x804,0x804,
-0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x804,
-0x807,0x804,0x807,0x804,0x807,0x804,0x807,0x80a,0x804,0x807,0x804,0x807,0x804,0x807,0x804,0x804,
-0x804,0x804,0x804,0x804,0x807,0x807,0x804,0x807,0x807,0x804,0x807,0x807,0x804,0x807,0x807,0x804,
-0x807,0x807,0x804,0x804,0x804,0x804,0x804,0x80a,0x804,0x80a,0x804,0x80a,0x804,0x804,0x804,0x804,
-0x804,0x804,0x80a,0x804,0x804,0x804,0x804,0x804,0x807,0x80a,0x80a,0x807,0x807,0x807,0x807,0x8dc,
-0x8df,0x80d,0x810,0xc42,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,
-0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,
-0x816,0x816,0x816,0x816,0x819,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,
-0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,0x816,
-0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,
-0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0x822,0xd44,0xd44,0xe76,0x81c,
-0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0xd3e,0xd3e,0xd3e,0xd3e,
-0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,0x825,
-0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,
-0x8f1,0x828,0x828,0x828,0x828,0x828,0x828,0xd47,0xd47,0xd47,0xd47,0x8f4,0x8f4,0x8f4,0x8f4,0x8f4,
-0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,
-0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,0x828,
-0x828,0x828,0xd47,0xd47,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,
-0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,0x82b,
-0x82b,0x82b,0x82b,0x82b,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x82e,0x82e,0x82e,0x82e,
-0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,
-0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0x82e,0xe79,0xe79,
-0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,
-0xe79,0xe79,0xe79,0xe79,0x10e9,0x10e9,0x10e9,0x10e9,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,
-0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,
-0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x834,0x834,0x831,0x834,0x831,0x834,
-0x834,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x831,0x834,0x831,0x834,0x831,0x834,
-0x834,0x831,0x831,0x834,0x834,0x834,0x831,0x831,0x831,0x831,0x148b,0x148b,0xc4b,0xc4b,0xc4b,0xc4b,
-0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0x8e8,0x8e8,0x8e8,0x8e8,
-0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,
-0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x8e8,0x12bd,0x12bd,0x12bd,0x12bd,
-0x1266,0x1266,0x1266,0x1266,0x1266,0x1266,0x1266,0x1266,0xd3e,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,
-0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,
-0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8ee,
-0x8eb,0x8ee,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,
-0x8eb,0x8eb,0x8eb,0x8eb,0x8eb,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,0xc45,
-0xc45,0xc45,0xc45,0xc45,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,
-0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,0x8f1,
-0x8f1,0x8f1,0x8f1,0xd47,0x96f,0x951,0x951,0x951,0x951,0x94b,0x951,0x951,0x963,0x951,0x951,0x94e,
-0x95a,0x960,0x960,0x960,0x960,0x960,0x963,0x94b,0x957,0x94b,0x94b,0x94b,0x942,0x942,0x94b,0x94b,
-0x94b,0x94b,0x94b,0x94b,0x966,0x966,0x966,0x966,0x966,0x966,0x966,0x966,0x966,0x966,0x94b,0x94b,
-0x94b,0x94b,0x94b,0x94b,0x94b,0x94b,0x94b,0x94b,0x94e,0x942,0x94b,0x942,0x94b,0x942,0x95d,0x954,
-0x95d,0x954,0x96c,0x96c,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,
-0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,0x97b,
-0x97b,0x97b,0x97b,0x97b,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,
-0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,0x97e,
-0x97e,0x97e,0x97e,0x97e,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,
-0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,0x981,
-0x981,0x981,0x981,0x981,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,
-0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,
-0x98a,0x98a,0x984,0x984,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,
-0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,
-0x98d,0x98d,0x987,0x987,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,
-0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,0x98a,
-0x98a,0x98a,0x98a,0x98a,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,
-0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,0x98d,
-0x98d,0x98d,0x98d,0x98d,0x990,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,
-0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,
-0x990,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,
-0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0x993,0xa20,0xa20,0xfab,0xa20,
-0xa20,0xa20,0xa23,0xa20,0xfab,0xa20,0xa20,0xfa2,0xa1a,0xa0e,0xa0e,0xa0e,0xa0e,0xa1d,0xa0e,0xf90,
-0xf90,0xf90,0xa0e,0xa11,0xa1a,0xa14,0xf96,0xfa5,0xfa5,0xf90,0xf90,0xfab,0xb13,0xb13,0xb13,0xb13,
-0xb13,0xb13,0xb13,0xb13,0xb13,0xb13,0xa26,0xa26,0xa17,0xa17,0xa17,0xa17,0xa20,0xa20,0xa20,0xa20,
-0xa20,0xa20,0xa1d,0xa1d,0xa0e,0xa0e,0xfab,0xfab,0xfab,0xfab,0xf90,0xf90,0xa20,0xa20,0xa20,0xa20,
-0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,
-0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa20,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0xd98,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xd98,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,
-0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa35,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,
-0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,
-0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa3b,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,
-0xa41,0xa41,0xa41,0xa41,0xa41,0xa3e,0xa44,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0x1122,
-0x1122,0x1122,0x1122,0x1122,0x1122,0x1122,0x1122,0x1122,0x111f,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,
+0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,0x243,
+0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,0x1851,
+0x1851,0x1851,0x1851,0x1851,0x246,0x246,0x246,0x246,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,
+0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,0x184e,
+0x184e,0x184e,0x184e,0x184e,0x246,0x246,0x246,0x246,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,
+0x186f,0x186f,0x186f,0x186f,0x186f,0x19e9,0x19e9,0x19e9,0x19e9,0x19e9,0x249,0x249,0x249,0x249,0x249,0x249,
+0x249,0x249,0x249,0x249,0x249,0x249,0x249,0x249,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,
+0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x24c,0x24c,0x24c,0x24c,0x24c,
+0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x24c,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,
+0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,
+0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x190e,0x24f,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x252,
+0x18ae,0x18ae,0x252,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,
+0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18ae,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x18a2,0x252,
+0x252,0x252,0x18a2,0x252,0x18a2,0x18a2,0x252,0x18a2,0x18a2,0x18a2,0x18a5,0x18a2,0x18a8,0x18a8,0x18b1,0x18a2,
+0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x252,0x18ab,0x18ab,0x18ab,0x18ab,0x18ab,0x18ab,0x18ab,0x18ab,
+0x18ab,0x18ab,0x252,0x252,0x252,0x252,0x252,0x252,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,
+0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,
+0x1911,0x1911,0x1911,0x1911,0x255,0x255,0x255,0x255,0x18c9,0x18c9,0x18c9,0x18c9,0x258,0x258,0x18cc,0x18cc,
+0x18cc,0x18cc,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18c6,
+0x18b7,0x18ba,0x18bd,0x18cf,0x18cf,0x196b,0x18c0,0x18c0,0x18de,0x18e1,0x18f0,0x18f0,0x18e1,0x18e4,0x18de,0x18db,
+0x25e,0x25e,0x25e,0x25e,0x25e,0x25e,0x25e,0x25e,0x18c9,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18b4,0x18c6,
+0x18c6,0x18b4,0x18b4,0x18b4,0x18c9,0x18c9,0x18c9,0x18c9,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,
+0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,
+0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x261,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,
+0x1980,0x1980,0x1980,0x1980,0x197d,0x197d,0x197d,0x1971,0x1971,0x1971,0x1971,0x1971,0x1971,0x1971,0x1971,0x1971,
+0x197d,0x1977,0x1974,0x197a,0x264,0x264,0x264,0x264,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,
+0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,0x1983,
+0x1983,0x1983,0x1983,0x267,0x267,0x1983,0x1983,0x1983,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x26a,0x1992,
+0x1992,0x26a,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,
+0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x1992,0x198f,0x198f,0x198f,0x198f,0x198f,0x26a,
+0x1986,0x1986,0x26a,0x198f,0x198f,0x1986,0x198f,0x1989,0x1992,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,0x26a,
+0x199b,0x199b,0x199e,0x199e,0x1995,0x1995,0x1995,0x1995,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,
+0x1998,0x1998,0x1998,0x1998,0x1998,0x1998,0x1998,0x1998,0x1998,0x1998,0x26d,0x26d,0x26d,0x26d,0x26d,0x26d,
+0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a4,0x19a1,0x19a1,0x19a1,
+0x19a4,0x19a1,0x19a1,0x19a1,0x19a1,0x270,0x270,0x270,0x270,0x270,0x270,0x270,0x270,0x270,0x270,0x270,
+0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,0x19ad,
+0x19ad,0x19ad,0x19ad,0x19a7,0x19a7,0x19aa,0x19aa,0x19b0,0x19b0,0x273,0x273,0x273,0x273,0x273,0x273,0x273,
+0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,0x19b3,
+0x19b3,0x19b3,0x19b3,0x19b3,0x276,0x276,0x276,0x276,0x276,0x276,0x276,0x276,0x276,0x276,0x276,0x276,
+0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,
+0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b6,0x19b9,0x19c2,0x19b6,0x19b6,0x279,0x279,0x279,0x279,0x279,
+0x19c5,0x19c5,0x19c5,0x19c5,0x19c5,0x19c5,0x19c5,0x19c8,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,0x27c,
+0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,0x19d1,
+0x19d1,0x19d1,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19cb,0x19ce,0x19ce,0x19ce,
+0x19ce,0x19d4,0x19d4,0x19d4,0x19d4,0x19d4,0x27f,0x27f,0x27f,0x27f,0x27f,0x27f,0x282,0x282,0x282,0x282,
+0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,
+0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x190b,0x29d,0x29d,0x29d,
+0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x29d,0x282,0x282,0x282,0x282,
+0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,
+0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x282,0x954,0x954,0xb1f,0xb1f,0xb1f,0xb1f,
+0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,
+0xb1f,0xb1f,0x285,0x285,0x285,0x285,0x285,0x285,0x285,0x285,0x285,0x285,0x18f6,0x18f6,0x18f6,0x18f6,
+0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x19da,0x19da,0x19da,0x19da,0x19da,0x288,0x288,0x288,0x288,
+0x288,0x288,0x288,0x288,0x288,0x288,0x288,0x288,0x288,0x288,0x288,0x288,0xc78,0xc78,0xc78,0xc78,
+0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0x12c0,0x12c0,0x12c0,0x28b,0x28b,0xeac,0xeac,0xeac,0xeac,
+0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,
+0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,
+0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,
+0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0x28b,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,
+0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0x28e,
+0x28e,0x28e,0x28e,0x28e,0x28e,0x28e,0x28e,0x28e,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,
+0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,
+0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0x291,0x291,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,
+0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x294,0x294,0x294,
+0x294,0x294,0x294,0x294,0x294,0x294,0x294,0x294,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,
+0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,
+0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x297,0x297,0x17b5,0x17b5,0x29a,0x29a,0x29a,0x29a,0x29a,0x29a,
+0x29a,0x29a,0x29a,0x29a,0x29a,0x29a,0x29a,0x29a,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,
+0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x1131,0x396,0x396,0x3a2,0xcba,0x3a5,0x3a5,0x3a5,
+0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,
+0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a2,0x396,0x396,0x396,0x396,0x396,0x396,0x396,
+0x396,0x3a2,0x3a2,0x3a2,0x3a2,0x39c,0x1134,0x1317,0x3a5,0x921,0x924,0x399,0x399,0x1131,0x1314,0x1314,
+0x3a8,0x3a8,0x3a8,0x3a8,0x3a8,0x3a8,0x3a8,0x3a8,0x3a5,0x3a5,0x396,0x396,0x8ac,0x8af,0x93f,0x93f,
+0x93f,0x93f,0x93f,0x93f,0x93f,0x93f,0x93f,0x93f,0x39f,0xf93,0xf90,0x131a,0x131a,0x131a,0x131a,0x131a,
+0x14df,0x1137,0x1137,0xee5,0xee5,0xdb3,0xee5,0xee5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,
+0x3a5,0x3a8,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a5,0x3a8,0x3a5,0x3a5,0x3a8,0x3a5,0x3a5,0x3a5,
+0x3a5,0x3a5,0x1314,0x1317,0x399,0x3a5,0x3a2,0x3a2,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,
+0x447,0x1320,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,0x447,
+0x447,0x447,0x1320,0x1887,0x1887,0xfb1,0x438,0x441,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,
+0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0x483,0xba0,
+0xba0,0xdbf,0xdbf,0x8b2,0xdc2,0x1401,0x1401,0x1401,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
+0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,
+0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x486,0x48c,0x48c,0x48c,0x114c,0x114c,0x114c,0x114c,0x114c,
+0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,
+0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,0x489,
+0x489,0x489,0x1149,0x1149,0x1149,0x1149,0x1149,0x1149,0x48f,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,
+0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,
+0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x48c,0x498,0x492,0x498,0x492,
+0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,
+0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x492,0x492,
+0x492,0x492,0x495,0x996,0xfe1,0xfe1,0xfe4,0xfe1,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,
+0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,0x498,0x492,
+0x498,0x492,0xfe4,0xfe1,0xfe4,0xfe1,0xfe4,0xfe1,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,0x4a4,
+0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x4a7,0x687,0x687,0x68a,0x4c2,0x696,0x693,0x693,0x690,
+0x4ec,0x4ec,0x4aa,0x4aa,0x4aa,0x4aa,0x4aa,0xac8,0x699,0x4ce,0x6b1,0x6b4,0x4e3,0x699,0x4d1,0x4d1,
+0x4c2,0x4dd,0x4dd,0x687,0x4e9,0x4e6,0x68d,0x4bc,0x4b3,0x4b3,0x4b6,0x4b6,0x4b6,0x4b6,0x4b6,0x4b9,
+0x4b6,0x4b6,0x4b6,0x4ad,0x4f5,0x4f2,0x4ef,0x4ef,0x6a5,0x4d7,0x4d4,0x6a2,0x69f,0x69c,0x6ae,0x4c5,
+0x6ab,0x6ab,0x4da,0x4dd,0x6a8,0x6a8,0x4da,0x4dd,0x4bf,0x4c2,0x4c2,0x4c2,0x4e0,0x4cb,0x4c8,0xbb5,
+0xace,0xad1,0xacb,0xacb,0xacb,0xacb,0xbac,0xbac,0xbac,0xbac,0xbb2,0xce7,0xce4,0xdce,0xdd1,0xbaf,
+0xdd1,0xdd1,0xdd1,0xdd1,0xdce,0xdd1,0xdd1,0xba9,0x519,0x519,0x519,0x519,0x519,0x519,0x519,0x516,
+0x51c,0x735,0x519,0x999,0x9ba,0xad4,0xad4,0xad4,0xbbb,0xbbb,0xdd7,0xdd7,0xdd7,0xdd7,0x1155,0x1158,
+0x1158,0x1335,0x14cd,0x14f7,0x14fa,0x14fa,0x170d,0x188a,0x528,0x528,0x540,0x6c3,0x525,0x6c0,0x528,0x53d,
+0x525,0x6c3,0x537,0x540,0x540,0x540,0x537,0x537,0x540,0x540,0x540,0x6cc,0x525,0x540,0x6c6,0x525,
+0x534,0x540,0x540,0x540,0x540,0x540,0x525,0x525,0x52b,0x6c0,0x6c9,0x525,0x540,0x525,0x6cf,0x525,
+0x540,0x52e,0x546,0x6d2,0x540,0x540,0x531,0x537,0x540,0x540,0x543,0x540,0x537,0x53a,0x53a,0x53a,
+0x53a,0xae0,0xadd,0xcea,0xde0,0xbd0,0xbd3,0xbd3,0xbcd,0xbca,0xbca,0xbca,0xbca,0xbd3,0xbd0,0xbd0,
+0xbd0,0xbd0,0xbc7,0xbca,0xddd,0xef1,0xef4,0xfea,0x115b,0x115b,0x115b,0x6d8,0x6d5,0x549,0x54c,0x54c,
+0x54c,0x54c,0x54c,0x6d5,0x6d8,0x6d8,0x6d5,0x54c,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,0x6de,
+0x6de,0x6de,0x6de,0x6de,0x555,0x555,0x555,0x555,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,0x6db,
+0x6db,0x6db,0x54f,0x54f,0x54f,0x54f,0x54f,0x54f,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,
+0x558,0x561,0x561,0x55b,0x55b,0x55b,0x55e,0x558,0x55b,0x55b,0x558,0x558,0x558,0x558,0x55b,0x55b,
+0x6e1,0x6e1,0x558,0x558,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,
+0x55b,0x55e,0x55e,0x55e,0x55b,0x55b,0x6e4,0x55b,0x6e4,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,0x55b,
+0x558,0x55b,0x558,0x558,0x558,0x558,0x558,0x558,0x55b,0x55b,0x558,0x6e1,0x558,0x558,0x558,0xae6,
+0xae6,0xae6,0xae6,0xae6,0xae6,0xae6,0xae6,0xae6,0xbd6,0xbd6,0xbd6,0xbd6,0xbd6,0xbd6,0xbd6,0xbd6,
+0xbd6,0xbd6,0xbd6,0xbd6,0x6ea,0x564,0x6ea,0x6ea,0x567,0x564,0x564,0x6ea,0x6ea,0x567,0x564,0x6ea,
+0x567,0x564,0x564,0x6ea,0x564,0x6ea,0x573,0x570,0x564,0x6ea,0x564,0x564,0x564,0x564,0x6ea,0x564,
+0x564,0x6ea,0x6ea,0x6ea,0x6ea,0x564,0x564,0x6ea,0x567,0x6ea,0x567,0x6ea,0x6ea,0x6ea,0x6ea,0x6ea,
+0x6f0,0x56a,0x6ea,0x56a,0x56a,0x564,0x564,0x564,0x6ea,0x6ea,0x6ea,0x6ea,0x564,0x564,0x564,0x564,
+0x6ea,0x6ea,0x564,0x564,0x564,0x567,0x564,0x564,0x567,0x564,0x564,0x567,0x6ea,0x567,0x564,0x564,
+0x6ea,0x564,0x564,0x564,0x564,0x564,0x6ea,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,
+0x564,0x564,0x564,0x564,0x6ed,0x6ea,0x567,0x564,0x6ea,0x6ea,0x6ea,0x6ea,0x564,0x564,0x6ea,0x6ea,
+0x564,0x567,0x6ed,0x6ed,0x567,0x567,0x564,0x564,0x567,0x567,0x564,0x564,0x567,0x567,0x564,0x564,
+0x564,0x564,0x564,0x564,0x567,0x567,0x6ea,0x6ea,0x567,0x567,0x6ea,0x6ea,0x567,0x567,0x564,0x564,
+0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x6ea,0x564,0x564,0x564,0x6ea,0x564,0x564,
+0x564,0x564,0x564,0x564,0x564,0x6ea,0x564,0x564,0x564,0x564,0x564,0x564,0x567,0x567,0x567,0x567,
+0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x6ea,
+0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,
+0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,0x564,
+0x567,0x567,0x567,0x567,0x564,0x564,0x564,0x564,0x564,0x564,0x567,0x567,0x567,0x567,0x564,0x56d,
+0x564,0x564,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,0xbd9,
+0x576,0xae9,0x576,0x576,0x576,0x576,0x576,0x576,0x582,0x57f,0x582,0x57f,0x576,0x576,0x576,0x576,
+0x576,0x576,0x6f3,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x7f8,0x7f8,0x576,0x576,0x576,0x576,
+0x57c,0x57c,0x576,0x576,0x576,0x576,0x576,0x576,0x579,0x7fe,0x7fb,0x576,0x576,0x576,0x576,0x576,
+0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,
+0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0x576,0xae9,
+0xbdf,0xae9,0xae9,0xae9,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,
+0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,0x585,
+0x585,0x585,0x585,0x585,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x58b,0xc48,
+0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,0xc48,
+0xc48,0xc48,0xc48,0xd62,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,
+0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x58e,0x591,0x591,0x591,0x591,0x591,0x591,0x591,
+0x591,0x591,0x591,0x591,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,
+0x591,0x591,0x591,0x591,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,
+0x705,0x705,0x705,0x705,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,0x708,
+0x708,0x708,0x708,0x708,0x594,0x594,0x708,0x708,0x708,0x708,0xbe2,0xbe2,0xbe2,0xbe2,0xbe2,0xbe2,
+0xbe2,0xbe2,0xbe2,0xbe2,0x70e,0x70e,0x597,0x70b,0x70b,0x70b,0x70b,0x70b,0x70b,0x70b,0x59a,0x59a,
+0x597,0x597,0x59d,0x59d,0x59d,0x59d,0x70e,0x70e,0x59d,0x59d,0x711,0x70e,0x597,0x597,0x597,0x597,
+0x70e,0x70e,0x59d,0x59d,0x711,0x70e,0x597,0x597,0x597,0x597,0x70e,0x70e,0x70b,0x597,0x59d,0x70e,
+0x597,0x597,0x70b,0x70e,0x70e,0x70e,0x59d,0x59d,0x597,0x597,0x597,0x597,0x597,0x597,0x597,0x597,
+0x597,0x597,0x597,0x597,0x597,0x597,0x70e,0x70b,0x70e,0x70b,0x597,0x59d,0x59d,0x59d,0x59d,0x59d,
+0x59d,0x597,0x597,0x70b,0xaf2,0xaf2,0xaf2,0xaf2,0xaf2,0xaf2,0xaf2,0xaf2,0xbe5,0xbe5,0xbe5,0xbe8,
+0xbe8,0xc63,0xc63,0xbe5,0x5ac,0x5ac,0x5ac,0x5ac,0x5a9,0x723,0x720,0x5a3,0x5a3,0x714,0x5a3,0x5a3,
+0x5a3,0x5a3,0x71a,0x714,0x5a3,0x5a9,0x5a3,0x5a0,0xd6b,0xd6b,0xbee,0xbee,0xdec,0xaf5,0x5a6,0x5a6,
+0x717,0x5af,0x717,0x5a6,0x5a9,0x5a3,0x5a9,0x5a9,0x5a3,0x5a3,0x5a9,0x5a3,0x5a3,0x5a3,0x5a9,0x5a3,
+0x5a3,0x5a3,0x5a9,0x5a9,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a9,0x5ac,0x5ac,0x5a6,
+0x5a3,0x5a3,0x5a3,0x5a3,0x726,0x5a3,0x726,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x801,0x801,0x801,0x801,
+0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x801,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,0x5a3,
+0x5a3,0x5a3,0x5a3,0x5a9,0x726,0x723,0x5b2,0x726,0x714,0x71a,0x5a9,0x714,0x71d,0x714,0x714,0x5a3,
+0x714,0x723,0x5b2,0x723,0xaf5,0xaf5,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf4,
+0xbf1,0xbf1,0xde9,0xea3,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,
+0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b5,0x5b8,0x13bf,0x13bf,0x13bf,0x5b8,0x5b8,0x5b8,0x5b8,
+0x5b8,0x5b8,0x5b8,0x5b8,0x1503,0x5c4,0x5cd,0x5c4,0x5c4,0x13bf,0x5b8,0x5b8,0x5cd,0x5cd,0x13c2,0x13c2,
+0x5d0,0x5d0,0x5c1,0x5c7,0x5c1,0x5c1,0x5c7,0x5b8,0x5c7,0x5b8,0x5c7,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,
+0x5b8,0x5c7,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x13bf,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,
+0x5b8,0x5b8,0x5b8,0x5c7,0x5c7,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x72c,0x5b8,0x5b8,
+0x5b8,0x5b8,0x5b8,0x5b8,0x5c7,0x5b8,0x5b8,0x5c7,0x5b8,0x5b8,0x5b8,0x5b8,0x13bf,0x5b8,0x13bf,0x5b8,
+0x5b8,0x5b8,0x5b8,0x13bf,0x13bf,0x13bf,0x5b8,0x12ba,0x5b8,0x5b8,0x5b8,0x5be,0x5be,0x5be,0x5be,0x1341,
+0x1341,0x5b8,0x5bb,0x5ca,0x5cd,0x5c1,0x5c1,0x5c1,0xbfa,0xbf7,0xbfa,0xbf7,0xbfa,0xbf7,0xbfa,0xbf7,
+0xbfa,0xbf7,0xbfa,0xbf7,0xbfa,0xbf7,0x729,0x729,0x729,0x729,0x729,0x729,0x729,0x729,0x729,0x729,
+0x5b8,0x5c7,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,
+0x13bf,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x5b8,0x13bf,
+0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f4,0x5f4,
+0x5f4,0x5f4,0x5f4,0x5f4,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5f1,0x5f7,0x5e8,0x5eb,
+0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,
+0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5ee,0x5ee,
+0x5ee,0x5ee,0x5ee,0x5ee,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,
+0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,
+0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,
+0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f7,0x5f1,0x5f4,0x5fa,
+0x5f7,0x5f1,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f4,0x5fa,0x5f7,0x5f1,0x5f7,0x5f1,0x1344,0x1344,
+0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x5f7,0x5f1,0x5f7,0x5f1,
+0x5f7,0x5f1,0x5f4,0x5fa,0x5f4,0x5fa,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,0x5f7,0x5f1,
+0x5f7,0x5f1,0x5f7,0x5f1,0x5f4,0x5f7,0x5f1,0x5f4,0x5f7,0x5f1,0x5f4,0x5fa,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f1,0x5f1,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f7,0x5f7,0x5f7,0x5f7,
+0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f4,0x5f1,0x5f4,
+0x5f1,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f4,0x5f4,
+0x5f1,0x5f1,0x5f1,0x5f4,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,
+0x5f4,0x5f4,0x5f1,0x5f1,0x5f4,0x5f1,0x5f4,0x5f1,0x5f1,0x5f1,0x5f1,0x5f1,0x5f4,0x5f4,0x5f4,0x5f4,
+0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,
+0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5f4,0x5fa,
+0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,
+0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,
+0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,
+0x5fa,0x5fa,0x5fa,0x5fa,0x5fa,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,0x5f7,
+0x5fd,0x5fd,0x5fd,0x5fd,0xff6,0xff6,0xff6,0x1506,0x1506,0x1506,0x1506,0x1506,0x1506,0x1506,0x1713,0x1713,
+0x85e,0x864,0x864,0x870,0x870,0x861,0x858,0x861,0x858,0x861,0x858,0x861,0x858,0x861,0x858,0x861,
+0x60c,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x60c,
+0x606,0x609,0x60f,0x60c,0x606,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,
+0x60f,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,
+0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,
+0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x60f,0x60c,0x606,0x609,0x6f9,0x6f9,0x6f9,0x6f9,
+0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,0x6f9,
+0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,
+0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,0x6f6,
+0x6f6,0x6f6,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x702,0x6ff,
+0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6ff,0x6fc,0x6fc,0x6fc,0x6fc,
+0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x6fc,0x705,0x705,0x705,0x705,
+0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,
+0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x705,0x72f,0x72f,0x72f,0x72f,
+0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,
+0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0x72f,0xc51,0x8c4,0x8be,0x8bb,
+0x8c1,0x8b8,0x744,0x747,0x747,0x747,0x747,0x747,0x747,0x747,0x747,0x747,0x8ca,0x744,0x744,0x744,
+0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,
+0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x744,0x8c7,0x8c7,
+0x74a,0x8d9,0x8dc,0x8e2,0x804,0x810,0x8f7,0x80d,0x8d0,0x8cd,0x8d0,0x8cd,0x8d6,0x8d3,0x8d6,0x8d3,
+0x8d0,0x8cd,0x80a,0x8e2,0x8d0,0x8cd,0x8d0,0x8cd,0x8d0,0x8cd,0x8d0,0x8cd,0x8e5,0x8ee,0x8eb,0x8eb,
+0x750,0x78c,0x78c,0x78c,0x78c,0x78c,0x78c,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,
+0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x786,0x753,0x76e,0x74d,0x774,0x777,
+0x771,0x789,0x789,0x789,0x789,0x789,0x789,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,
+0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x783,0x753,0x76e,0x74d,0x76e,0xc54,
+0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,
+0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,0x7f2,
+0x7f2,0x7f2,0x12b4,0x12b4,0x12b4,0x12b4,0x12b4,0x7f5,0x80a,0x80d,0x80d,0x80d,0x80d,0x80d,0x80d,0x80d,
+0x80d,0x80d,0x92d,0x92d,0x92d,0x92d,0x813,0x813,0x8e8,0x8f4,0x8f4,0x8f4,0x8f4,0x8f1,0x807,0x8df,
+0xb19,0xb19,0xb19,0xc66,0xc84,0xc81,0xb34,0x8b5,0x819,0x816,0x819,0x81c,0x816,0x819,0x816,0x819,
+0x816,0x819,0x816,0x816,0x816,0x816,0x816,0x816,0x819,0x819,0x816,0x819,0x819,0x816,0x819,0x819,
+0x816,0x819,0x819,0x816,0x819,0x819,0x816,0x816,0xc87,0x82b,0x825,0x82b,0x825,0x82b,0x825,0x82b,
+0x825,0x82b,0x825,0x825,0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x825,
+0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x825,0x828,0x82b,0x825,0x828,0x825,0x828,
+0x825,0x828,0x825,0x825,0x825,0x825,0x825,0x825,0x828,0x828,0x825,0x828,0x828,0x825,0x828,0x828,
+0x825,0x828,0x828,0x825,0x828,0x828,0x825,0x825,0x825,0x825,0x825,0x82b,0x825,0x82b,0x825,0x82b,
+0x825,0x825,0x825,0x825,0x825,0x825,0x82b,0x825,0x825,0x825,0x825,0x825,0x828,0x82b,0x82b,0x828,
+0x828,0x828,0x828,0x8fd,0x900,0x82e,0x831,0xc6f,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,
+0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,
+0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x83a,0x837,0x837,0x837,0x837,0x837,0x837,0x837,
+0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,0x837,
+0x837,0x837,0x837,0x837,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,
+0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,0x843,
+0xd74,0xd74,0xea6,0x83d,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,
+0xd6e,0xd6e,0xd6e,0xd6e,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,0x846,
+0x846,0x846,0x846,0x846,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,
+0x912,0x912,0x912,0x912,0x912,0x849,0x849,0x849,0x849,0x849,0x849,0xd77,0xd77,0xd77,0xd77,0x915,
+0x915,0x915,0x915,0x915,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,
+0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,0x849,
+0x849,0x849,0x849,0x849,0x849,0x849,0xd77,0xd77,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,
+0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,
+0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x84c,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,
+0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,
+0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,0x84f,
+0x84f,0x84f,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,
+0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0xea9,0x1119,0x1119,0x1119,0x1119,0x852,0x852,0x852,0x852,
+0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,
+0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x855,0x855,
+0x852,0x855,0x852,0x855,0x855,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x852,0x855,
+0x852,0x855,0x852,0x855,0x855,0x852,0x852,0x855,0x855,0x855,0x852,0x852,0x852,0x852,0x14be,0x14be,
+0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,
+0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,
+0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,0x909,
+0x12f6,0x12f6,0x12f6,0x12f6,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0x1299,0xd6e,0xc72,0xc72,0xc72,
+0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0x90c,0x90c,0x90c,0x90c,
+0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,
+0x90c,0x90c,0x90c,0x90f,0x90c,0x90f,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,
+0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0x90c,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,
+0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0xc72,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,
+0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,0x912,
+0x912,0x912,0x912,0x912,0x912,0x912,0x912,0xd77,0x990,0x972,0x972,0x972,0x972,0x96c,0x972,0x972,
+0x984,0x972,0x972,0x96f,0x97b,0x981,0x981,0x981,0x981,0x981,0x984,0x96c,0x978,0x96c,0x96c,0x96c,
+0x963,0x963,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x987,0x987,0x987,0x987,0x987,0x987,0x987,0x987,
+0x987,0x987,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x96c,0x96f,0x963,0x96c,0x963,
+0x96c,0x963,0x97e,0x975,0x97e,0x975,0x98d,0x98d,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,
+0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,
+0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99c,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,
+0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,
+0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x99f,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,
+0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,
+0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9a2,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,
+0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,
+0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9a5,0x9a5,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,
+0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,
+0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9a8,0x9a8,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,
+0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,
+0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ab,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,
+0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,
+0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9ae,0x9b1,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,
+0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,
+0x9b4,0x9b4,0x9b4,0x9b4,0x9b1,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,
+0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,0x9b4,
+0xa41,0xa41,0xfdb,0xa41,0xa41,0xa41,0xa44,0xa41,0xfdb,0xa41,0xa41,0xfd2,0xa3b,0xa2f,0xa2f,0xa2f,
+0xa2f,0xa3e,0xa2f,0xfc0,0xfc0,0xfc0,0xa2f,0xa32,0xa3b,0xa35,0xfc6,0xfd5,0xfd5,0xfc0,0xfc0,0xfdb,
+0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xa47,0xa47,0xa38,0xa38,0xa38,0xa38,
+0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa3e,0xa3e,0xa2f,0xa2f,0xfdb,0xfdb,0xfdb,0xfdb,0xfc0,0xfc0,
+0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,
 0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,
-0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa41,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
 0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,
-0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa7a,0xa7a,0xa7a,0xa7d,
-0xa7d,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,
-0xa62,0xa62,0xa77,0xa59,0xa59,0xa59,0xa59,0xa59,0xa59,0xa59,0xa77,0xa77,0xa7a,0xa7a,0xa7a,0xa7a,
-0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,
-0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa9b,0xa9b,0xa9b,0xa9b,
-0xa9b,0xa86,0xa86,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
+0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xdcb,0xa56,0xa56,0xa56,0xa56,
+0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa56,0xa5c,0xa5c,0xa5c,0xa5c,
+0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,
+0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa5c,0xa62,0xa62,0xa62,0xa62,
+0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa5f,0xa65,0xa62,0xa62,0xa62,0xa62,0xa62,
+0xa62,0xa62,0xa62,0x1152,0x1152,0x1152,0x1152,0x1152,0x1152,0x1152,0x1152,0x1152,0x114f,0xa62,0xa62,0xa62,
+0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,
+0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,0xa62,
+0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,
+0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,0xa77,
+0xa9b,0xa9b,0xa9b,0xa9e,0xa9e,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
+0xa9b,0xa9b,0xa9b,0xa9b,0xa83,0xa83,0xa98,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa7a,0xa98,0xa98,
 0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
-0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9e,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
 0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,0xa9b,
-0xa9b,0xa9b,0xa9b,0xa9b,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,
-0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xac5,0xbb8,
-0xbb8,0xbb8,0xbb8,0xbb8,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,
-0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,0xad1,
-0xad1,0xad1,0xad1,0xad1,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,
-0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,0xae3,
-0xae3,0xae3,0xae3,0xae3,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,
-0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,
-0xae9,0xae9,0xae9,0xae9,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xaa7,0xaa7,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabf,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,
+0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xabc,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,
+0xaec,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,0xae9,
+0xae9,0xae9,0xae9,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,
 0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,
-0xaf8,0xaf8,0xaf8,0xaf8,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,
-0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafe,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,
-0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,
-0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xafb,0xb01,0xb01,0xc48,0xc48,
-0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,
-0xc48,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb01,0xb22,0xb22,0xb22,0xb22,
+0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xaf8,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,
+0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,
+0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb0a,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,
+0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,
+0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb10,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,
+0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,
+0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb1f,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,
+0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb25,0xb22,0xb22,
 0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,
-0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0x14d9,0xb2b,0xb2b,0xb2b,0xb2b,
-0xb2b,0xb2b,0xccf,0xccf,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,
-0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xccc,0xccc,
-0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,
-0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,
-0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,0xb2b,
-0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,
-0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,0xb2e,
-0xb3d,0xb3d,0xb3d,0xb3d,0xb3d,0xb34,0xb40,0xb46,0xb46,0xb46,0xb3a,0xb3a,0xb3a,0xb43,0xb37,0xb37,
-0xb37,0xb37,0xb37,0xb31,0xb31,0xb31,0xb31,0xb31,0xb31,0xb31,0xb31,0xb46,0xb46,0xb46,0xb46,0xb46,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3d,0xb3d,0xb46,0xb46,0xb46,0xb3a,0xb3a,0xb46,0xb46,0xb46,0xb46,0xb46,0xb46,0xb46,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb46,0xb46,0xb46,0xb46,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3d,0xb3d,0xb3d,0xb3d,0xb3d,0xb3d,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,
-0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0xb3a,0x16e6,0x16e6,0xb52,0xb49,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb49,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb49,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb49,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb49,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,
-0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,0xb4c,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
+0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,0xb22,
+0xb28,0xb28,0xc75,0xc75,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,
+0xb28,0xb28,0xb28,0xb28,0xc75,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,0xb28,
+0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,
+0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0xb49,0x1509,
+0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xcff,0xcff,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
 0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
+0xb4f,0xb4f,0xcfc,0xcfc,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,
+0xd4d,0xd4d,0xd4d,0xd4d,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
 0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,
-0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb52,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,0xb4f,
-0xb4f,0xb4f,0xb4f,0xb4f,0xb52,0xb52,0xb52,0xb52,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,
+0xb52,0xb52,0xb52,0xb52,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,
 0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,
-0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb55,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,
-0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,
-0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5b,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,
-0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,
-0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,
-0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb8,0xbb5,0xbb8,
-0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xbb5,0xcc0,
-0xcc3,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xdb0,0xecd,0xecd,0xecd,0xecd,
-0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xbc7,0xcc6,0xcc6,0xcc6,0xcc6,0xcc6,0xcc6,
-0xcc6,0xcc6,0xdb6,0xe70,0xdb6,0xdb9,0xdb9,0xdb6,0xdb3,0xdb6,0xdb3,0xdb6,0xdb6,0xfc0,0x1257,0x1257,
-0xdc2,0xdc2,0xdc2,0xdc2,0xdc2,0xdc8,0xdc5,0xedf,0xedf,0xedf,0xedf,0x13d4,0xfd2,0x13d4,0x1311,0x1311,
-0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,0xbfd,
-0xbfd,0xbfd,0xc2d,0xc2a,0xc2d,0xc2a,0xc2d,0xc2a,0x10e3,0x10e0,0xfd8,0xfd5,0xc00,0xc00,0xc00,0xc00,
-0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc00,0xc03,0xc03,0xc03,0xc03,
-0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,
-0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc06,0xc06,0xc03,0xc03,
-0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc03,0xc09,0xc09,0xc09,0xc0f,0xc0c,0xc33,0xc30,0xc0f,
-0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,0xc0c,0xc0f,
-0xc0c,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,
-0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,
-0xc09,0xc09,0xc09,0xc09,0xc0f,0xc0c,0xc0f,0xc0c,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,
-0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,0xc09,
-0xc09,0xc09,0xc09,0xc09,0xc0f,0xc0c,0xc09,0xc09,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,
-0xc12,0xc12,0xc12,0xc12,0xc18,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,
-0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,
-0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc18,0xc18,0xc18,0xc12,0xc12,0xc12,0xc12,0xc12,
-0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,
-0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc12,0xc15,0xc12,0xc12,0xc12,0xc4b,0xc4b,0xc4b,0xc4b,
-0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,
-0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xc4b,0xcc9,0xd38,0xdb3,0xdb3,
-0xdb3,0xdb3,0xdb3,0xdb3,0xdb3,0xdb3,0xe70,0xe70,0xdb3,0xdb3,0xdb3,0xdb3,0xdb6,0xdb6,0xed0,0xfc0,
-0xfc0,0xfc0,0xfc0,0xfc0,0xfc0,0xfc0,0xfc0,0xfc0,0xfc0,0x1284,0x1284,0x125a,0xced,0xced,0xced,0xced,
-0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,
-0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xced,0xcfc,0xcfc,0xcfc,0xcfc,
-0xcfc,0xcfc,0xcf3,0xcf3,0xcf3,0xcf3,0xcf3,0xcf0,0xd05,0xd05,0xd05,0xcff,0xd05,0xd05,0xd05,0xd05,
-0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xcff,0xd05,0xd05,0xd05,0xd05,0xcf9,0xcf9,0xd02,0xd02,
-0xd02,0xd02,0xcf6,0xcf6,0xcf6,0xcf6,0xcf6,0xcfc,0xdce,0xdce,0xdce,0xdce,0xdce,0xdce,0xdce,0xdce,
-0xdce,0xdce,0xdce,0xdce,0xdcb,0xdce,0xdce,0xdce,0xdce,0xdce,0xdce,0xdce,0xd05,0xd05,0xd05,0xd05,
-0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xcff,0xd05,0xd05,0xd05,0xd05,0xd05,
-0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xd05,0xcf9,0xcf9,0xcf9,0xcfc,0xcfc,0xcfc,0xcfc,
-0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,
-0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xcfc,0xd08,0xd08,0xd08,0xd08,
-0xd08,0xd0b,0xd0b,0xd0b,0xd08,0xd08,0xd08,0xd08,0xd08,0xd08,0xdd1,0xdd1,0xdd1,0xdd1,0xdd1,0xdd1,
-0xee2,0xee2,0xee2,0xee2,0xee2,0xee2,0xee2,0x10ec,0x10ec,0xfdb,0xfdb,0xfdb,0xd0e,0xd0e,0xd0e,0xd0e,
-0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,
-0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd0e,0xd14,0xd14,0xd14,0xd14,
-0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,
-0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd14,0xd1d,0xd1d,0xd1d,0xd1d,
+0xb55,0xb55,0xb55,0xb55,0xb64,0xb64,0xb64,0xb64,0xb64,0xb5b,0xb67,0xb6d,0xb6d,0xb6d,0xb61,0xb61,
+0xb61,0xb6a,0xb5e,0xb5e,0xb5e,0xb5e,0xb5e,0xb58,0xb58,0xb58,0xb58,0xb58,0xb58,0xb58,0xb58,0xb6d,
+0xb6d,0xb6d,0xb6d,0xb6d,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb64,0xb64,0xb6d,0xb6d,0xb6d,0xb61,0xb61,0xb6d,0xb6d,0xb6d,
+0xb6d,0xb6d,0xb6d,0xb6d,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb6d,0xb6d,0xb6d,0xb6d,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb64,0xb64,0xb64,0xb64,0xb64,
+0xb64,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,
+0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0xb61,0x1716,0x1716,
+0xb79,0xb70,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb70,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb70,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb70,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb70,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,
+0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,0xb73,
+0xb73,0xb73,0xb73,0xb73,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,
+0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb79,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,
+0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb76,0xb79,0xb79,0xb79,0xb79,0xb7c,0xb7c,0xb7c,0xb7c,
+0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,
+0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb7c,0xb82,0xb82,0xb82,0xb82,
+0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,
+0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb82,0xb85,0xb85,0xb85,0xb85,
+0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,
+0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xb85,0xbdf,0xbdf,0xbdf,0xbdf,
+0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,0xbdf,
+0xbdf,0xbdf,0xbdc,0xbdf,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,0xbdc,
+0xbdc,0xbdc,0xbdc,0xced,0xcf0,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,0xde3,
+0xefd,0xefd,0xefd,0xefd,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbf1,0xbeb,0xbeb,0xbeb,0xbeb,0xcf3,0xcf3,
+0xcf3,0xcf3,0xcf3,0xcf3,0xcf6,0xcf6,0xde9,0xea0,0xde9,0xde9,0xde9,0xde9,0xde6,0xde9,0xde6,0xde9,
+0xde9,0xff0,0x128a,0x128a,0xdf2,0xdf2,0xdf2,0xdf2,0xdf2,0xdf8,0xdf5,0xf0f,0xf0f,0xf0f,0xf0f,0x1407,
+0x1002,0x1407,0x134d,0x134d,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,
+0xc27,0xc27,0xc27,0xc27,0xc27,0xc27,0xc5a,0xc57,0xc5a,0xc57,0xc5a,0xc57,0x1113,0x1110,0x1008,0x1005,
+0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,0xc2a,
+0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,
+0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,
+0xc30,0xc30,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc2d,0xc33,0xc33,0xc33,0xc39,
+0xc36,0xc60,0xc5d,0xc39,0xc36,0xc39,0xc36,0xc39,0xc36,0xc39,0xc36,0xc39,0xc36,0xc39,0xc36,0xc39,
+0xc36,0xc39,0xc36,0xc39,0xc36,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,
+0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,
+0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc39,0xc36,0xc39,0xc36,0xc33,0xc33,0xc33,0xc33,
+0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,
+0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc33,0xc39,0xc36,0xc33,0xc33,0xc3c,0xc3c,0xc3c,0xc3c,
+0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc42,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,
+0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,
+0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc42,0xc42,0xc42,0xc3c,
+0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,
+0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3c,0xc3f,0xc3c,0xc3c,0xc3c,
+0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,
+0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,0xc78,
+0xcf9,0xd68,0xde6,0xde6,0xde6,0xde6,0xde6,0xde6,0xde6,0xde6,0xea0,0xea0,0xde6,0xde6,0xde6,0xde6,
+0xde9,0xde9,0xf00,0xff0,0xff0,0xff0,0xff0,0xff0,0xff0,0xff0,0xff0,0xff0,0xff0,0x12b7,0x12b7,0x128d,
 0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,
-0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd29,0xd29,0xd29,0xd29,
-0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,
-0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd29,0xd35,0xd35,0xd35,0xd35,
-0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,
-0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xdd7,0xdd7,0xdd7,0xdd7,
-0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,
-0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xdd7,0xddd,0xddd,0xddd,0xddd,
-0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,
-0xddd,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xdda,0xddd,0xddd,0xddd,0xddd,
-0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,
-0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xddd,0xe9d,0xe9d,0xdef,0xdef,
-0xee5,0xee5,0xee5,0xee5,0xee5,0xee5,0xee5,0xfe7,0xfe7,0xfe7,0xfe7,0xfe7,0xfe4,0xfe4,0xfe4,0xfe4,
-0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xfe4,0xdfe,0xdfb,0xdfe,0xdfb,
-0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,
-0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xdfe,0xdfb,0xe0a,0xe0a,0xe0a,0xe0a,
-0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,
-0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe10,0xe10,0xe10,0xe10,
-0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,
-0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe10,0xe28,0xe28,0xe28,0xe28,
-0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,0xe28,
-0xe28,0xe28,0xe28,0xee8,0xee8,0xee8,0xee8,0xfea,0xfea,0xfea,0xfea,0xfea,0xe31,0xe31,0xe31,0xe31,
-0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,
-0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe31,0xe3a,0xe3a,0xe3a,0xe3a,
+0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,0xd1d,
+0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd23,0xd23,0xd23,0xd23,0xd23,0xd20,0xd35,0xd35,0xd35,0xd2f,
+0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd2f,0xd35,0xd35,0xd35,0xd35,
+0xd29,0xd29,0xd32,0xd32,0xd32,0xd32,0xd26,0xd26,0xd26,0xd26,0xd26,0xd2c,0xdfe,0xdfe,0xdfe,0xdfe,
+0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfb,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,0xdfe,
+0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd2f,0xd35,
+0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd35,0xd29,0xd29,0xd29,
+0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,
+0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,0xd2c,
+0xd38,0xd38,0xd38,0xd38,0xd38,0xd3b,0xd3b,0xd3b,0xd38,0xd38,0xd38,0xd38,0xd38,0xd38,0xe01,0xe01,
+0xe01,0xe01,0xe01,0xe01,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0xf12,0x111c,0x111c,0x100b,0x100b,0x100b,
+0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,
+0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,0xd3e,
+0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,
+0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,0xd44,
+0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,
+0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,0xd4d,
+0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,
+0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,0xd59,
+0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,
+0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,0xd65,
+0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,
+0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,0xe07,
+0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,
+0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,0xe0a,
+0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,
+0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,0xe0d,
+0xecd,0xecd,0xe1f,0xe1f,0xf15,0xf15,0xf15,0xf15,0xf15,0xf15,0xf15,0x1017,0x1017,0x1017,0x1017,0x1017,
+0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,0x1014,
+0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,
+0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,0xe2e,0xe2b,
+0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,
 0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,
-0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe3a,0xe43,0xe43,0xe43,0xe43,
-0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,
-0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe43,0xe3d,0xe40,0xe40,0xe40,0xe40,
 0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,
-0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe43,0xe43,0xe43,0xe43,0xe43,0xe4c,0xe4c,0xe4c,0xe4c,
-0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe4c,0xe49,0xe49,0xe49,0xe49,0xe49,0xe49,
-0xe49,0xe49,0xe46,0xe4f,0xff6,0xff0,0xfff,0xfed,0xe4c,0xe4c,0xfed,0xfed,0xe61,0xe61,0xe52,0xe61,
-0xe61,0xe61,0xe58,0xe61,0xe61,0xe61,0xe61,0xe52,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,
-0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe64,0xe64,0xe64,0xe64,
-0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,
-0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe64,0xe7c,0xe7c,0xe7c,0xe7c,
-0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,
-0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe9a,0xe9a,0xe9a,0xe9a,
-0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0xe9a,0x10f5,0x10f5,0x10f5,0x10f5,
-0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0x10f5,0xecd,0xecd,0xecd,0xeca,
-0xeca,0xeca,0xeca,0xeca,0x112e,0x137a,0x137a,0x137a,0x137a,0x12fc,0x12fc,0x12fc,0x137d,0x12ff,0x12ff,0x137d,
-0x14cd,0x14cd,0x14cd,0x14cd,0x14d0,0x14d0,0x14d0,0x1797,0x1797,0x1797,0x1797,0x185d,0xee2,0xee2,0xee2,0xee2,
-0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfde,0xfde,0xfde,0xfde,
-0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xfde,0xf03,0xf03,0xf03,0xf03,
-0xf15,0xf1e,0xf21,0xf1e,0xf21,0xf1e,0xf21,0xf1e,0xf21,0xf1e,0xf21,0xf1e,0xf1e,0xf1e,0xf21,0xf1e,
-0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,0xf1e,
-0xf1e,0xf1e,0xf1e,0xf1e,0xf06,0xf15,0xf03,0xf03,0xf03,0xf03,0xf03,0xf18,0xf03,0xf18,0xf15,0xf15,
-0xf2a,0xf27,0xf2a,0xf2a,0xf2a,0xf27,0xf27,0xf2a,0xf27,0xf2a,0xf27,0xf2a,0xf27,0x1011,0x1011,0x1011,
-0x114c,0x1008,0x1011,0x1008,0xf27,0xf2a,0xf27,0xf27,0x1008,0x1008,0x1008,0x1008,0x100b,0x100e,0x114c,0x114c,
-0xf2d,0xf2d,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,
-0x101a,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,
-0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,
-0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,0xf33,
-0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,
-0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,0xf42,
-0xf42,0xf42,0xf42,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,0x150c,
-0x150c,0x150c,0x150c,0x150c,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,
-0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,0xf48,
-0xf48,0xf48,0xf48,0xf48,0xf90,0xfab,0xfa2,0xf9f,0xf9f,0xfab,0xfab,0xfa2,0xfa2,0xf9f,0xf9f,0xf9f,
-0xf9f,0xf9f,0xfab,0xfab,0xfab,0xf90,0xf90,0xf90,0xf90,0xfab,0xfab,0xfab,0xfab,0xfab,0xfab,0xfab,
-0xfab,0xfab,0xfab,0xfab,0xfab,0xfab,0xf90,0xfa2,0xfa5,0xf90,0xf90,0xfa8,0xfa8,0xfa8,0xfa8,0xfa8,
-0xfa8,0xf93,0xfab,0xfa8,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0xf9c,0x1116,0x1116,
-0x1113,0x1110,0xf99,0xf99,0xfc3,0xfc3,0xfc3,0xfc3,0x1284,0x1284,0x125a,0x125a,0x1260,0x1257,0x1257,0x1257,
-0x1257,0x125a,0x1380,0x1260,0x125a,0x1260,0x1257,0x1260,0x1284,0x1257,0x1257,0x1257,0x125a,0x125a,0x1257,0x1257,
-0x125a,0x1257,0x1257,0x125a,0xfde,0xfde,0xfde,0xfde,0xfde,0xfdb,0xfdb,0xfde,0xfde,0xfde,0xfde,0xfde,
-0xfde,0x14e5,0x14e5,0x14e5,0x10ec,0xfdb,0xfdb,0xfdb,0xfdb,0x1290,0x1269,0x1269,0x1269,0x1269,0x14e5,0x14e5,
-0x14e5,0x14e5,0x14e5,0x14e5,0xffc,0xffc,0xff9,0xff3,0xff9,0xff3,0xff9,0xff3,0xff9,0xff3,0xff0,0xff0,
-0xff0,0xff0,0x1005,0x1002,0xff0,0x1149,0x13e0,0x13e3,0x13e3,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e6,0x13e6,
-0x1500,0x14f4,0x14f4,0x14f1,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1017,0x1014,0x1014,0x1023,
-0x101a,0x1320,0x131d,0x16ef,0x1320,0x131d,0x13ef,0x13ec,0x1503,0x1503,0x1509,0x1503,0x1509,0x1503,0x1509,0x1503,
-0x1509,0x1503,0x1509,0x1503,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,
-0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,0x1023,0x101a,
-0x1023,0x101a,0x1023,0x101a,0x101d,0x101a,0x101a,0x101a,0x101a,0x101a,0x101a,0x101a,0x101a,0x1023,0x101a,0x1023,
-0x101a,0x1023,0x1023,0x101a,0x1026,0x1026,0x102c,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,
-0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,0x1032,
-0x1032,0x1032,0x1032,0x1032,0x1032,0x102c,0x1026,0x1026,0x1026,0x1026,0x102c,0x102c,0x1026,0x1026,0x102f,0x13f8,
-0x13f5,0x13f5,0x1032,0x1032,0x1029,0x1029,0x1029,0x1029,0x1029,0x1029,0x1029,0x1029,0x1029,0x1029,0x13fb,0x13fb,
-0x13fb,0x13fb,0x13fb,0x13fb,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,
-0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,0x1047,
-0x1047,0x1047,0x1047,0x1047,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,
-0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1050,0x1053,0x1053,0x1053,0x1056,
-0x1053,0x1053,0x1059,0x1059,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,
-0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,0x105c,
-0x105c,0x105c,0x105c,0x105c,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,
-0x1068,0x105f,0x106e,0x106b,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,
-0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,0x1065,
-0x1065,0x1065,0x1065,0x1065,0x1326,0x1323,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,
-0x1080,0x107a,0x107d,0x10fe,0x1071,0x1071,0x1071,0x1077,0x13fe,0x13fe,0x13fe,0x13fe,0x13fe,0x13fe,0x13fe,0x13fe,
-0x1074,0x1074,0x1077,0x1083,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,
-0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,0x1080,0x107a,
-0x1080,0x107a,0x1080,0x107a,0x1518,0x1515,0x1518,0x1515,0x151b,0x151b,0x16f8,0x13fe,0x108c,0x108c,0x108f,0x108f,
-0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,
-0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108f,0x108c,0x108c,0x108c,0x108c,
-0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x1095,0x1095,
-0x1095,0x1095,0x1095,0x1098,0x1098,0x1098,0x10f2,0x10a1,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,
-0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x10b0,0x109b,0x109b,0x109b,0x109b,0x109b,0x109b,0x109b,0x109b,
-0x109b,0x109b,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,
-0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x109e,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,
+0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,0xe40,
+0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,
+0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xe58,0xf18,0xf18,0xf18,0xf18,0x101a,0x101a,0x101a,0x101a,0x101a,
+0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,
+0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,0xe61,
+0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,
+0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,0xe6a,
+0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,
+0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe73,0xe6d,
+0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,
+0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe70,0xe73,0xe73,0xe73,0xe73,0xe73,
+0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe7c,0xe79,0xe79,
+0xe79,0xe79,0xe79,0xe79,0xe79,0xe79,0xe76,0xe7f,0x1026,0x1020,0x102f,0x101d,0xe7c,0xe7c,0x101d,0x101d,
+0xe91,0xe91,0xe82,0xe91,0xe91,0xe91,0xe88,0xe91,0xe91,0xe91,0xe91,0xe82,0xe91,0xe91,0xe91,0xe91,
+0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,0xe91,
+0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,
+0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,0xe94,
+0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,
+0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,0xeac,
+0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,0xeca,
+0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,0x1125,
+0xefd,0xefd,0xefd,0xefa,0xefa,0xefa,0xefa,0xefa,0x115e,0x13b6,0x13b6,0x13b6,0x13b6,0x1338,0x1338,0x1338,
+0x13b9,0x133b,0x133b,0x13b9,0x14fd,0x14fd,0x14fd,0x14fd,0x1500,0x1500,0x1500,0x17c7,0x17c7,0x17c7,0x17c7,0x188d,
+0xf12,0xf12,0xf12,0xf12,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,0x100b,
+0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,0x100e,
+0xf33,0xf33,0xf33,0xf33,0xf45,0xf4e,0xf51,0xf4e,0xf51,0xf4e,0xf51,0xf4e,0xf51,0xf4e,0xf51,0xf4e,
+0xf4e,0xf4e,0xf51,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,
+0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf4e,0xf36,0xf45,0xf33,0xf33,0xf33,0xf33,0xf33,0xf48,
+0xf33,0xf48,0xf45,0xf45,0xf5a,0xf57,0xf5a,0xf5a,0xf5a,0xf57,0xf57,0xf5a,0xf57,0xf5a,0xf57,0xf5a,
+0xf57,0x1041,0x1041,0x1041,0x117c,0x1038,0x1041,0x1038,0xf57,0xf5a,0xf57,0xf57,0x1038,0x1038,0x1038,0x1038,
+0x103b,0x103e,0x117c,0x117c,0xf5d,0xf5d,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,
+0x1053,0x104a,0x1053,0x104a,0x104a,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,
+0x1053,0x104a,0x1053,0x104a,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,
+0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,0xf63,
+0xf63,0xf63,0xf63,0xf63,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,
+0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,
+0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0xf72,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,
+0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,
+0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,
+0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xf78,0xfc0,0xfdb,0xfd2,0xfcf,0xfcf,0xfdb,0xfdb,0xfd2,
+0xfd2,0xfcf,0xfcf,0xfcf,0xfcf,0xfcf,0xfdb,0xfdb,0xfdb,0xfc0,0xfc0,0xfc0,0xfc0,0xfdb,0xfdb,0xfdb,
+0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfdb,0xfc0,0xfd2,0xfd5,0xfc0,0xfc0,0xfd8,
+0xfd8,0xfd8,0xfd8,0xfd8,0xfd8,0xfc3,0xfdb,0xfd8,0xfcc,0xfcc,0xfcc,0xfcc,0xfcc,0xfcc,0xfcc,0xfcc,
+0xfcc,0xfcc,0x1146,0x1146,0x1143,0x1140,0xfc9,0xfc9,0xff3,0xff3,0xff3,0xff3,0x12b7,0x12b7,0x128d,0x128d,
+0x1293,0x128a,0x128a,0x128a,0x128a,0x128d,0x13bc,0x1293,0x128d,0x1293,0x128a,0x1293,0x12b7,0x128a,0x128a,0x128a,
+0x128d,0x128d,0x128a,0x128a,0x128d,0x128a,0x128a,0x128d,0x100e,0x100e,0x100e,0x100e,0x100e,0x100b,0x100b,0x100e,
+0x100e,0x100e,0x100e,0x100e,0x100e,0x1515,0x1515,0x1515,0x111c,0x100b,0x100b,0x100b,0x100b,0x12c3,0x129c,0x129c,
+0x129c,0x129c,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x102c,0x102c,0x1029,0x1023,0x1029,0x1023,0x1029,0x1023,
+0x1029,0x1023,0x1020,0x1020,0x1020,0x1020,0x1035,0x1032,0x1020,0x1179,0x1413,0x1416,0x1416,0x1413,0x1413,0x1413,
+0x1413,0x1413,0x1419,0x1419,0x1530,0x1524,0x1524,0x1521,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,
+0x1047,0x1044,0x1044,0x1053,0x104a,0x135c,0x1359,0x171f,0x135c,0x1359,0x1422,0x141f,0x1533,0x1533,0x1539,0x1533,
+0x1539,0x1533,0x1539,0x1533,0x1539,0x1533,0x1539,0x1533,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,
+0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,
+0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x104a,0x104d,0x104a,0x104a,0x104a,0x104a,0x104a,0x104a,0x104a,
+0x104a,0x1053,0x104a,0x1053,0x104a,0x1053,0x1053,0x104a,0x1056,0x1056,0x105c,0x1062,0x1062,0x1062,0x1062,0x1062,
+0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,
+0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x1062,0x105c,0x1056,0x1056,0x1056,0x1056,0x105c,0x105c,
+0x1056,0x1056,0x105f,0x142b,0x1428,0x1428,0x1062,0x1062,0x1059,0x1059,0x1059,0x1059,0x1059,0x1059,0x1059,0x1059,
+0x1059,0x1059,0x142e,0x142e,0x142e,0x142e,0x142e,0x142e,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,
+0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,
+0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1077,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,
+0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,0x1080,
+0x1083,0x1083,0x1083,0x1086,0x1083,0x1083,0x1089,0x1089,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,
+0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,
+0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x108c,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,
+0x1095,0x1095,0x1095,0x1095,0x1098,0x108f,0x109e,0x109b,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,
+0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,
+0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1095,0x1362,0x135f,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,
+0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10ad,0x112e,0x10a1,0x10a1,0x10a1,0x10a7,0x1431,0x1431,0x1431,0x1431,
+0x1431,0x1431,0x1431,0x1431,0x10a4,0x10a4,0x10a7,0x10b3,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,
+0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,
+0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x10b0,0x10aa,0x1548,0x1545,0x1548,0x1545,0x154b,0x154b,0x1728,0x1431,
+0x10bc,0x10bc,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,
 0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,
-0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10bf,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,
-0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,
-0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10d1,0x10da,0x10da,0x10da,0x10da,0x10ef,0x10da,0x10da,0x10da,
-0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,
-0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10da,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,
-0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,
-0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10dd,0x10e9,0x10e9,0x10e9,0x10e9,0x128a,0x128a,0x128a,0x128a,
-0x128a,0x128a,0x128a,0x128a,0x1488,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x18c6,0x18c6,
-0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x18c6,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,
-0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x115e,0x1155,0x1155,
-0x1158,0x1158,0x115e,0x1155,0x1155,0x1155,0x1155,0x1155,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,
-0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,
-0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x1161,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,
-0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,
-0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x117c,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,
-0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,
-0x1188,0x1188,0x1188,0x1188,0x1188,0x1188,0x1185,0x118b,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,
-0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,
-0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x1197,0x11a6,0x11a6,0x11a6,0x11b5,0x11bb,0x11bb,0x11bb,0x11bb,
+0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10bc,0x10ce,0x10ce,0x10ce,0x10ce,
+0x10ce,0x10ce,0x10c5,0x10c5,0x10c5,0x10c5,0x10c5,0x10c8,0x10c8,0x10c8,0x1122,0x10d1,0x10e0,0x10e0,0x10e0,0x10e0,
+0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10e0,0x10cb,0x10cb,0x10cb,0x10cb,
+0x10cb,0x10cb,0x10cb,0x10cb,0x10cb,0x10cb,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,
+0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ce,0x10ef,0x10ef,0x10ef,0x10ef,
+0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,
+0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x10ef,0x1101,0x1101,0x1101,0x1101,
+0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,
+0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x1101,0x110a,0x110a,0x110a,0x110a,
+0x111f,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,
+0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110a,0x110d,0x110d,0x110d,0x110d,
+0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,
+0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x110d,0x1119,0x1119,0x1119,0x1119,
+0x12bd,0x12bd,0x12bd,0x12bd,0x12bd,0x12bd,0x12bd,0x12bd,0x14bb,0x17a6,0x17a6,0x17a6,0x17a6,0x17a6,0x17a6,0x17a6,
+0x17a6,0x17a6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x18f6,0x118e,0x118e,0x118e,0x118e,
+0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,0x118e,
+0x118e,0x118e,0x1185,0x1185,0x1188,0x1188,0x118e,0x1185,0x1185,0x1185,0x1185,0x1185,0x1194,0x1194,0x1194,0x1194,
+0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,
+0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x1194,0x11af,0x11af,0x11af,0x11af,
+0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,
+0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11af,0x11bb,0x11bb,0x11bb,0x11bb,
 0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,
-0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11a9,0x11b5,0x11b5,0x11a6,0x11a6,
-0x11a6,0x11a6,0x11b5,0x11b5,0x11a6,0x11b5,0x11b5,0x11b5,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,
-0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11ca,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c7,0x11c1,
-0x11c1,0x11c1,0x11c7,0x11c4,0x1521,0x1524,0x1527,0x1527,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,
-0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11cd,0x11d9,0x11cd,0x11cd,0x11cd,0x11e2,0x11e2,0x11cd,
-0x11cd,0x11e2,0x11d9,0x11e2,0x11e2,0x11d9,0x11cd,0x11d0,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,
-0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,
-0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11d9,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,
-0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,
-0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x11f4,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,
+0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11bb,0x11b8,0x11be,0x11ca,0x11ca,0x11ca,0x11ca,
+0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,
+0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11ca,0x11d0,0x11d0,0x11d0,0x11d0,
+0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x11d0,0x1308,0x11d6,0x130b,
+0x11d6,0x11d6,0x11d6,0x11d6,0x11d3,0x11d3,0x11d3,0x11d6,0x172b,0x172e,0x1950,0x194d,0x11d9,0x11d9,0x11d9,0x11e8,
+0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,
+0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11ee,0x11dc,
+0x11e8,0x11e8,0x11d9,0x11d9,0x11d9,0x11d9,0x11e8,0x11e8,0x11d9,0x11e8,0x11e8,0x11e8,0x11fa,0x11fa,0x11fa,0x11fa,
+0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fa,0x11fd,0x11fa,0x11fa,0x11fa,
+0x11fa,0x11fa,0x11fa,0x11f4,0x11f4,0x11f4,0x11fa,0x11f7,0x1551,0x1554,0x1557,0x1557,0x120c,0x120c,0x120c,0x120c,
+0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x1200,0x120c,0x1200,0x1200,
+0x1200,0x1215,0x1215,0x1200,0x1200,0x1215,0x120c,0x1215,0x1215,0x120c,0x1200,0x1203,0x120c,0x120c,0x120c,0x120c,
 0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,
-0x120c,0x120c,0x120c,0x120c,0x120c,0x1209,0x1209,0x1209,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,
-0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,
-0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1215,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,
-0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,
-0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x1224,0x122a,0x122a,0x1239,0x123c,0x123c,0x123c,0x123c,0x123c,
-0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,
-0x123c,0x123c,0x123f,0x123c,0x123f,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,0x123c,
-0x123c,0x123c,0x123c,0x123f,0x123c,0x123c,0x123c,0x123c,0x1239,0x1239,0x1239,0x122d,0x122d,0x122d,0x122d,0x1239,
-0x1239,0x1233,0x1230,0x1236,0x1236,0x1245,0x1242,0x1242,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,
-0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,
-0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x124e,0x124e,0x124e,0x124b,0x124b,0x124b,0x1248,0x1248,
-0x1248,0x1248,0x124b,0x1248,0x1248,0x1248,0x124e,0x124b,0x124e,0x124b,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,
+0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x120c,0x1227,0x1227,0x1227,0x1227,
+0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,
+0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x1227,0x123f,0x123f,0x123f,0x123f,
+0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,
+0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123f,0x123c,0x123c,0x123c,0x1248,0x1248,0x1248,0x1248,
 0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,
-0x1248,0x1248,0x1248,0x1248,0x1248,0x124e,0x124b,0x124b,0x1248,0x1248,0x1248,0x1248,0x125a,0x125a,0x1302,0x1257,
-0x1302,0x1302,0x1302,0x1302,0x1257,0x125d,0x1284,0x1257,0x1257,0x1257,0x1257,0x1257,0x125d,0x1260,0x1284,0x1284,
-0x1260,0x1284,0x1257,0x1260,0x1260,0x1263,0x1284,0x1257,0x1257,0x1284,0x125a,0x125a,0x1371,0x1371,0x1371,0x1371,
-0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,0x126c,0x126c,0x126c,0x126c,0x138c,0x136b,0x1275,0x138c,0x138c,0x138c,
-0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x138c,0x1824,0x1824,0x1824,0x1824,0x1824,0x1374,0x1374,0x127b,0x1374,
-0x1374,0x1374,0x127b,0x1374,0x1374,0x1374,0x1275,0x1275,0x1275,0x1275,0x1275,0x136e,0x1371,0x1371,0x1371,0x1371,
-0x1371,0x1371,0x1371,0x1278,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,0x1371,0x1278,0x12a2,0x12a2,0x12a2,0x12a2,
-0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,
-0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x1344,0x1344,0x1344,0x1344,
-0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,
-0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1344,0x1359,0x134a,0x1359,0x135c,
-0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,
-0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x135c,0x134a,0x134a,0x134a,0x134a,
-0x134a,0x134a,0x134a,0x134a,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,
-0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,0x1362,
-0x1362,0x1362,0x1362,0x1362,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,
-0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,0x1368,
-0x1368,0x1368,0x1368,0x1368,0x1398,0x1395,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,
-0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,
-0x18cc,0x18cc,0x18cc,0x18cc,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x139e,0x139e,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x139e,0x13a1,0x13a1,0x13a1,0x139e,0x13a1,0x139e,0x13a1,0x139e,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a7,0x13a1,
-0x13a1,0x13a1,0x13a1,0x139e,0x13a1,0x139e,0x139e,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,
-0x13a4,0x13a1,0x13a1,0x13a1,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x139e,0x139e,0x139e,0x139e,0x139e,
-0x139e,0x139e,0x139e,0x139e,0x139e,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x1533,0x1533,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x153c,0x1536,0x1536,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x1779,0x1779,0x1779,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x153c,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x153c,0x1779,0x1779,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a7,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a4,0x1536,0x1536,0x153c,0x153c,0x1536,0x153c,0x153c,0x153c,0x1533,0x1533,0x153c,0x153c,
-0x13a1,0x13a1,0x13a7,0x13a7,0x13a7,0x16aa,0x13a1,0x13a7,0x13a1,0x13a1,0x13a7,0x1542,0x1542,0x153c,0x153c,0x1779,
-0x1779,0x1779,0x1779,0x1779,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,0x153c,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a4,0x13a1,0x13a1,
-0x13a1,0x1536,0x1536,0x153c,0x16aa,0x153c,0x1536,0x153c,0x1779,0x1779,0x1779,0x177c,0x177c,0x177c,0x177c,0x177c,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x153c,
-0x13a1,0x153c,0x13a7,0x13a7,0x13a1,0x13a1,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,
-0x13a7,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13aa,0x13aa,0x13aa,0x13aa,0x13a1,0x13a1,0x13a1,0x13a1,0x13a7,0x13a1,0x13a7,0x13a7,0x13a7,0x13a7,
-0x13a7,0x13a7,0x13a7,0x13a7,0x13a7,0x13a1,0x13a1,0x13a1,0x13a7,0x13a1,0x13a1,0x13a1,0x13a1,0x13a7,0x13a7,0x13a7,
-0x13a1,0x13a7,0x13a7,0x13a7,0x13a1,0x13a1,0x13a1,0x13a4,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x16aa,0x13a1,0x13a1,0x13a1,0x13a1,0x153c,0x1536,0x1779,0x1404,0x1404,0x1404,0x1404,0x1533,0x1533,0x1533,0x1533,
-0x1533,0x1539,0x153c,0x1779,0x1779,0x1779,0x1779,0x1701,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x153c,
-0x153c,0x1536,0x1536,0x153c,0x1542,0x1542,0x153c,0x153c,0x153c,0x153c,0x182d,0x1536,0x1536,0x1536,0x1536,0x1536,
-0x1536,0x153c,0x1536,0x153c,0x1536,0x1536,0x1536,0x1536,0x153f,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x153c,
-0x1536,0x1536,0x1536,0x153c,0x1533,0x1533,0x1533,0x1533,0x1533,0x1533,0x153c,0x13a1,0x13a1,0x13a1,0x13a1,0x13a1,
-0x148e,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,
-0x13ad,0x148e,0x13ad,0x13ad,0x13ad,0x148e,0x13ad,0x148e,0x13ad,0x148e,0x13ad,0x148e,0x13ad,0x13ad,0x13ad,0x148e,
-0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x148e,0x148e,0x13ad,0x13ad,0x13ad,0x13ad,0x148e,0x13ad,0x148e,0x148e,
-0x13ad,0x13ad,0x13ad,0x13ad,0x148e,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,
-0x13ad,0x16b0,0x16b0,0x177f,0x177f,0x13b0,0x13b0,0x13b0,0x13ad,0x13ad,0x13ad,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,
-0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,
-0x13b6,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,
-0x13b3,0x13b3,0x13b6,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,
-0x13b3,0x13b3,0x13b3,0x13b9,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,
-0x13b3,0x13b3,0x13b3,0x13b3,0x13b9,0x13b9,0x13b9,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,0x13b3,
-0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,
-0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,0x13bc,
-0x17ac,0x17ac,0x17a9,0x1704,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x1407,0x1407,0x1407,0x1407,0x1407,0x1407,
-0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x140a,0x154b,
-0x1416,0x1416,0x1416,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,
-0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,0x1428,
-0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,
-0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,0x1443,
-0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,
-0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,0x144c,
-0x1452,0x1452,0x145e,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,
-0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,0x1464,
-0x1464,0x1464,0x1464,0x145e,0x145e,0x145e,0x1452,0x1452,0x1452,0x1452,0x1452,0x1452,0x1452,0x1452,0x1452,0x145e,
-0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,
-0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,
-0x1536,0x1536,0x153c,0x153c,0x153c,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,
-0x1536,0x153c,0x153c,0x153c,0x1533,0x1533,0x1533,0x1533,0x1533,0x1533,0x1533,0x1533,0x153c,0x153c,0x153c,0x1536,
-0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x153c,0x1536,0x1536,0x153c,0x153c,0x153c,0x153c,0x1536,0x1536,
-0x1542,0x1536,0x1536,0x1536,0x1536,0x16ad,0x16ad,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,
-0x182a,0x153c,0x1536,0x1536,0x153c,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x153c,0x153c,0x1536,
-0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x1536,0x153c,0x1536,0x1536,0x1536,0x1563,0x1563,0x1563,0x1563,
-0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,
-0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1563,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,
-0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x1575,0x157b,0x157b,0x157b,0x157b,
-0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,
-0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157b,0x157e,0x157e,0x157e,0x157e,
-0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,
-0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x157e,0x15bd,0x15bd,0x15bd,0x15bd,
-0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,
-0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15bd,0x15ae,0x15c6,0x15c6,0x15c6,0x15c6,
-0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,
-0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c6,0x15c0,0x15c9,0x15c9,0x15c9,0x15c9,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,
-0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15cc,0x15e7,0x15e7,0x15e7,0x15e7,
-0x15e7,0x15e7,0x15e7,0x15e7,0x15de,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,
-0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15e7,0x15f0,0x15f0,0x15f0,0x15f0,
-0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,
-0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x15f0,0x1602,0x1602,0x1602,0x1602,
-0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x15ff,0x15ff,0x15ff,0x15f3,
-0x15f3,0x15f3,0x15f3,0x15f3,0x15f3,0x15f3,0x15f3,0x15ff,0x15ff,0x15f3,0x15ff,0x15f6,0x1602,0x1602,0x1602,0x1602,
-0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,
-0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1602,0x1626,0x1626,0x1626,0x1626,
-0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,
-0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1626,0x1623,0x1623,0x1623,0x162f,0x162f,0x162f,0x162f,
-0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,0x162f,
-0x162f,0x162f,0x1635,0x1635,0x1635,0x1632,0x1632,0x1632,0x162f,0x162f,0x162f,0x162f,0x1644,0x1644,0x1644,0x1644,
-0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1638,0x1638,0x1638,0x1638,
-0x1638,0x1638,0x1638,0x164a,0x164a,0x163e,0x163b,0x163b,0x163b,0x163b,0x163b,0x163b,0x1644,0x1644,0x1644,0x1644,
-0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,
-0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1644,0x1650,0x1650,0x1650,0x1650,
-0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,0x1650,
-0x1650,0x1650,0x1650,0x164d,0x164d,0x164d,0x164d,0x164d,0x164d,0x164d,0x164d,0x164d,0x1653,0x1653,0x1653,0x1653,
-0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,
-0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1653,0x1677,0x1677,0x1677,0x1677,
-0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,
-0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1677,0x1680,0x1680,0x1680,0x1680,
-0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,
-0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1698,0x1698,0x1698,0x1698,
-0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1683,0x1692,0x1692,0x1683,
-0x1683,0x1683,0x1683,0x1683,0x1683,0x1692,0x1683,0x1695,0x1695,0x1683,0x1695,0x1683,0x1698,0x1698,0x1698,0x1698,
-0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,
-0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x1698,0x16a1,0x16a1,0x16a1,0x16a1,
-0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,
-0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a1,0x16a7,0x16a7,0x16a7,0x16a7,
+0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1248,0x1257,0x1257,0x1257,0x1257,
+0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,
+0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x1257,0x125d,0x125d,0x126c,0x126f,
+0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,
+0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x1272,0x126f,0x1272,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,
+0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x126f,0x1272,0x126f,0x126f,0x126f,0x126f,0x126c,0x126c,0x126c,0x1260,
+0x1260,0x1260,0x1260,0x126c,0x126c,0x1266,0x1263,0x1269,0x1269,0x1278,0x1275,0x1275,0x127b,0x127b,0x127b,0x127b,
+0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,
+0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x1281,0x1281,0x1281,0x127e,
+0x127e,0x127e,0x127b,0x127b,0x127b,0x127b,0x127e,0x127b,0x127b,0x127b,0x1281,0x127e,0x1281,0x127e,0x127b,0x127b,
+0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,
+0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x127b,0x1281,0x127e,0x127e,0x127b,0x127b,0x127b,0x127b,
+0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a2,0x12a5,0x12a5,0x12a5,0x1284,0x1956,
+0x13b0,0x12ae,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x13b0,0x12ae,0x13b0,0x12ae,
+0x128d,0x128d,0x133e,0x128a,0x133e,0x133e,0x133e,0x133e,0x128a,0x1290,0x12b7,0x128a,0x128a,0x128a,0x128a,0x128a,
+0x1290,0x1293,0x12b7,0x12b7,0x1293,0x12b7,0x128a,0x1293,0x1293,0x1296,0x12b7,0x128a,0x128a,0x12b7,0x128d,0x128d,
+0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x129f,0x129f,0x129f,0x129f,0x13c8,0x13a7,
+0x12a8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x13c8,0x1854,0x1854,0x1854,0x1854,0x1854,
+0x13b0,0x13b0,0x12ae,0x13b0,0x13b0,0x13b0,0x12ae,0x13b0,0x13b0,0x13b0,0x12a8,0x12a8,0x12a8,0x12a8,0x12a8,0x13aa,
+0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x12ab,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x13ad,0x12ab,
+0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,
+0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,0x12d5,
+0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,
+0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,0x1380,
+0x1395,0x1386,0x1395,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,
+0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,0x1398,
+0x1386,0x1386,0x1386,0x1386,0x1386,0x1386,0x1386,0x1386,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,
+0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,
+0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x139e,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,
+0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,
+0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13a4,0x13d4,0x13d1,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,
+0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,
+0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13da,0x13da,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13da,0x13dd,0x13dd,0x13dd,0x13da,0x13dd,0x13da,0x13dd,0x13da,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13e0,0x13dd,0x13dd,0x13dd,0x13dd,0x13da,0x13dd,0x13da,0x13da,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13da,
+0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,0x13da,
+0x13da,0x13da,0x1563,0x1563,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x156f,0x1569,0x1569,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,
+0x156f,0x17a9,0x17a9,0x17a9,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x156f,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x156f,0x17a9,0x17a9,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13e0,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x1569,0x1569,0x156f,0x156f,0x1569,0x156f,0x156f,0x156f,0x1566,0x1566,0x156f,0x156f,0x13dd,0x13dd,0x13e0,0x13e0,
+0x13e0,0x16da,0x13dd,0x13e0,0x13dd,0x13dd,0x13e0,0x1572,0x1572,0x156f,0x156f,0x17a9,0x17a9,0x17a9,0x17a9,0x17a9,
+0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x156f,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x1569,0x1569,0x156f,
+0x16da,0x156f,0x1569,0x156f,0x17a9,0x17a9,0x17a9,0x17ac,0x17ac,0x17ac,0x17ac,0x17ac,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x156f,0x13dd,0x156f,0x13e0,0x13e0,
+0x13dd,0x13dd,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13e0,0x13e0,
+0x13e0,0x13e0,0x13dd,0x13dd,0x13dd,0x13dd,0x13e0,0x13dd,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,0x13e0,
+0x13e0,0x13dd,0x13dd,0x13dd,0x13e0,0x13dd,0x13dd,0x13dd,0x13dd,0x13e0,0x13e0,0x13e0,0x13dd,0x13e0,0x13e0,0x13e0,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x16da,0x13dd,0x13dd,0x13dd,0x13dd,0x156f,0x1569,0x17a9,
+0x1437,0x1437,0x1437,0x1437,0x1563,0x1563,0x1566,0x1566,0x1566,0x156c,0x156f,0x17a9,0x17a9,0x17a9,0x17a9,0x1731,
+0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,
+0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,0x156f,0x1569,0x1569,0x156f,0x1572,0x1572,0x156f,0x156f,
+0x156f,0x156f,0x185d,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,0x1569,0x156f,0x1569,0x1569,0x1569,0x1569,
+0x156f,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,0x1569,0x1569,0x1569,0x156f,0x1566,0x1566,0x1566,0x1566,
+0x1566,0x1566,0x156f,0x13dd,0x13dd,0x13dd,0x13dd,0x13dd,0x14c1,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,
+0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x14c1,0x13e3,0x13e3,0x13e3,0x14c1,0x13e3,0x14c1,
+0x13e3,0x14c1,0x13e3,0x14c1,0x13e3,0x13e3,0x13e3,0x14c1,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x14c1,0x14c1,
+0x13e3,0x13e3,0x13e3,0x13e3,0x14c1,0x13e3,0x14c1,0x14c1,0x13e3,0x13e3,0x13e3,0x13e3,0x14c1,0x13e3,0x13e3,0x13e3,
+0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x13e3,0x16e0,0x16e0,0x17af,0x17af,0x13e6,0x13e6,0x13e6,
+0x13e3,0x13e3,0x13e3,0x13e6,0x13e6,0x13e6,0x13e6,0x13e6,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,
+0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,
+0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,
+0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13ec,0x13e9,0x13e9,0x13e9,0x13e9,
+0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13ec,0x13ec,0x13ec,0x13e9,
+0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13e9,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,
+0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,
+0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x13ef,0x17dc,0x17dc,0x17d9,0x1734,0x143d,0x143d,0x143d,0x143d,
+0x143d,0x143d,0x143a,0x143a,0x143a,0x143a,0x143a,0x143a,0x143d,0x143d,0x143d,0x143d,0x143d,0x143d,0x143d,0x143d,
+0x143d,0x143d,0x143d,0x143d,0x143d,0x143d,0x143d,0x157b,0x1449,0x1449,0x1449,0x145b,0x145b,0x145b,0x145b,0x145b,
+0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,
+0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x145b,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,
+0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,
+0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x1476,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,
+0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,
+0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x147f,0x1485,0x1485,0x1491,0x1497,0x1497,0x1497,0x1497,0x1497,
+0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,
+0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1497,0x1491,0x1491,0x1491,0x1485,0x1485,
+0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1485,0x1491,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,
+0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,
+0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x14b8,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,
+0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,0x1515,
+0x1515,0x1515,0x192c,0x192c,0x192c,0x1515,0x1515,0x1515,0x1569,0x1569,0x156f,0x156f,0x156f,0x1569,0x1569,0x1569,
+0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,0x156f,0x156f,0x1566,0x1566,0x1566,0x1566,
+0x1566,0x1566,0x1566,0x1566,0x156f,0x156f,0x156f,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,
+0x1569,0x1569,0x156f,0x156f,0x156f,0x156f,0x1569,0x1569,0x1572,0x1569,0x1569,0x1569,0x1569,0x16dd,0x16dd,0x1569,
+0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x185a,0x156f,0x1569,0x1569,0x156f,0x1569,0x1569,0x1569,
+0x1569,0x1569,0x1569,0x1569,0x1569,0x156f,0x156f,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,0x1569,
+0x156f,0x1569,0x1569,0x1569,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,
+0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,0x1593,
+0x1593,0x1593,0x1593,0x1593,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,
+0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,0x15a5,
+0x15a5,0x15a5,0x15a5,0x15a5,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,
+0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,0x15ab,
+0x15ab,0x15ab,0x15ab,0x15ab,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,
+0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,0x15ae,
+0x15ae,0x15ae,0x15ae,0x15ae,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,
+0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,0x15ed,
+0x15ed,0x15ed,0x15ed,0x15de,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,
+0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f6,0x15f0,
+0x15f9,0x15f9,0x15f9,0x15f9,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,
+0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,0x15fc,
+0x15fc,0x15fc,0x15fc,0x15fc,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x160e,0x1617,0x1617,0x1617,
+0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,0x1617,
+0x1617,0x1617,0x1617,0x1617,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,
+0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,0x1620,
+0x1620,0x1620,0x1620,0x1620,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,
+0x1632,0x1632,0x1632,0x1632,0x162f,0x162f,0x162f,0x1623,0x1623,0x1623,0x1623,0x1623,0x1623,0x1623,0x1623,0x162f,
+0x162f,0x1623,0x162f,0x1626,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,
+0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,0x1632,
+0x1632,0x1632,0x1632,0x1632,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,
+0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,0x1656,
+0x1656,0x1653,0x1653,0x1653,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,
+0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x165f,0x1665,0x1665,0x1665,0x1662,0x1662,0x1662,
+0x165f,0x165f,0x165f,0x165f,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,
+0x1674,0x1674,0x1674,0x1674,0x1668,0x1668,0x1668,0x1668,0x1668,0x1668,0x1668,0x167a,0x167a,0x166e,0x166b,0x166b,
+0x166b,0x166b,0x166b,0x166b,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,
+0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,0x1674,
+0x1674,0x1674,0x1674,0x1674,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,
+0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x1680,0x167d,0x167d,0x167d,0x167d,0x167d,
+0x167d,0x167d,0x167d,0x167d,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,
+0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,0x1683,
+0x1683,0x1683,0x1683,0x1683,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,
 0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,
-0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x16a7,0x170a,0x170a,0x170a,0x170a,
-0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,
-0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x170a,0x1746,0x1746,0x1746,0x1746,
-0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,
-0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x174c,0x1749,
-0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,0x1746,
-0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,
-0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,0x174f,
-0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,
-0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,0x1752,
-0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,
-0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,0x1764,
-0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,
-0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,0x1767,
-0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,
-0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,
-0x176a,0x176a,0x176a,0x176d,0x176d,0x176d,0x176d,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,0x176a,
-0x176a,0x176a,0x176a,0x176a,0x176a,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176a,0x176d,0x176d,
-0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,
-0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,0x176d,
-0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,
-0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,0x1785,
-0x17ca,0x17ca,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,
-0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,0x17c7,
-0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,
-0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,0x17ca,
-0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,
-0x1818,0x1818,0x1818,0x1818,0x1818,0x1815,0x1815,0x1815,0x1800,0x1800,0x1800,0x1800,0x1800,0x1800,0x1800,0x1800,
-0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,
-0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,0x1818,
-0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,
-0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,0x183f,
-0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,
-0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,0x1842,
-0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,
-0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,0x1899,
-0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,
-0x18ba,0x18ba,0x18ba,0x18a5,0x18ab,0x18a8,0x18a8,0x18a8,0x18a8,0x18b7,0x18bd,0x18a8,0x18a8,0x18a8,0x18a8,0x18b4,
-0x18ba,0x18a8,0x18a8,0x18a8,0x18a8,0x18a8,0x18a8,0x18b7,0x18b7,0x18a8,0x18a8,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,
-0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,0x18ba,
-0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,
-0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,0x18cc,
-0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,
-0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,0x18db,
-0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,0x18e1,
-0,0,0,0
+0x16a7,0x16a7,0x16a7,0x16a7,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,0x16b0,
+0x16b0,0x16b0,0x16b0,0x16b0,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,
+0x16c8,0x16c8,0x16c8,0x16c8,0x16b3,0x16c2,0x16c2,0x16b3,0x16b3,0x16b3,0x16b3,0x16b3,0x16b3,0x16c2,0x16b3,0x16c5,
+0x16c5,0x16b3,0x16c5,0x16b3,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,
+0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,0x16c8,
+0x16c8,0x16c8,0x16c8,0x16c8,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,
+0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,0x16d1,
+0x16d1,0x16d1,0x16d1,0x16d1,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,
+0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,0x16d7,
+0x16d7,0x16d7,0x16d7,0x16d7,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,
+0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,0x173a,
+0x173a,0x173a,0x173a,0x173a,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,
+0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,
+0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x177c,0x1779,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,
+0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x1776,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,
+0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,
+0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x177f,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,
+0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,
+0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1782,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,
+0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,
+0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1794,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,
+0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,
+0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x1797,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,
+0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,
+0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179d,0x179d,0x179d,0x179d,0x179a,
+0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179a,0x179d,0x179d,0x179d,
+0x179d,0x179d,0x179d,0x179d,0x179d,0x179a,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,
+0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,
+0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x179d,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,
+0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,
+0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b5,0x17b8,0x17b8,0x17b8,0x17b8,0x17b8,0x1866,0x1866,0x1866,
+0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,
+0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x17fa,0x17fa,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,
+0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,
+0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17f7,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,
+0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,
+0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x17fa,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,
+0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1845,0x1845,0x1845,
+0x1830,0x1830,0x1830,0x1830,0x1830,0x1830,0x1830,0x1830,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,
+0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,
+0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1848,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1863,0x1866,
+0x1866,0x1866,0x1866,0x1866,0x1902,0x19e0,0x19e0,0x19e0,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,
+0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1866,0x1902,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,
+0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,
+0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x186f,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,
+0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,
+0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x1872,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,
+0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,
+0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18c9,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,
+0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18d5,0x18db,0x18d8,0x18d8,0x18d8,
+0x18d8,0x18e7,0x18ed,0x18d8,0x18d8,0x18d8,0x18d8,0x18e4,0x18ea,0x18d8,0x18d8,0x18d8,0x18d8,0x18d8,0x18d8,0x18d8,
+0x18d8,0x18d8,0x18d8,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,
+0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18ea,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,
+0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,
+0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x18fc,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x1902,0x19e0,
+0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,
+0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x19e0,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,
+0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,
+0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x190b,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,
+0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,
+0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1911,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,
+0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,
+0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x1980,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,
+0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,
+0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x199b,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,
+0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,
+0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19a1,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,
+0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,
+0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bc,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,
+0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,
+0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19bf,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,
+0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,
+0x19c8,0x19c8,0x19c8,0x19c8,0x19c8,0x19c5,0x19c5,0x19c5,0,0,0,0
 };
 
 static const UTrie2 propsVectorsTrie={
     propsVectorsTrie_index,
-    propsVectorsTrie_index+4880,
+    propsVectorsTrie_index+4948,
     NULL,
-    4880,
-    24356,
+    4948,
+    25064,
     0xa40,
-    0x1390,
+    0x13d4,
     0x0,
     0x0,
     0x110000,
-    0x7230,
+    0x7538,
     NULL, 0, FALSE, FALSE, 0, NULL
 };
 
-static const uint32_t propsVectors[6375]={
-0x67,0,0,0x67,0,0xe00000,0x67,0x80000,0x20,0x867,0,0,0xa67,0,0,0xb67,
+static const uint32_t propsVectors[6639]={
+0x67,0,0,0x67,0,0x4e00000,0x67,0x80000,0x20,0x867,0,0,0xa67,0,0,0xb67,
 0,0,0xc67,0,0,0xd67,0,0,0xe67,0,0,0x1067,0,0,0x1167,0,
 0,0x1267,0,0,0x1367,0,0,0x1467,0,0,0x1567,0,0,0x1667,0,0,
 0x1767,0,0,0x1867,0,0,0x1967,0,0,0x1a67,0,0,0x1b67,0,0,0x1d67,
@@ -3220,206 +3287,209 @@ static const uint32_t propsVectors[6375]={
 0,0x9367,0,0,0x9567,0,0,0x9667,0,0,0x9767,0,0,0x9867,0,0,
 0x9967,0,0,0x9a67,0,0,0x9c67,0,0,0x9f67,0,0,0xa167,0,0,0xa367,
 0,0,0xa467,0,0,0xa567,0,0,0xa667,0,0,0xa767,0,0,0xa867,0,
-0,0xa967,0,0,0xaa67,0,0xe00000,0xab67,0,0xe00000,0xac67,0,0,0xad67,0,0,
-0xae67,0,0,0xaf67,0,0,0xb167,0,0,0xb267,0,0,0xb367,0,0,0xb467,
-0,0,0xb567,0,0,0xb767,0,0,0xb867,0,0,0xb967,0,0,0xba67,0,
-0,0xbc67,0,0,0xbd67,0,0,0xbe67,0,0,0xbf67,0,0,0xc067,0,0,
-0xc167,0,0,0xc267,0,0,0xc367,0,0xe00000,0xc467,0,0xe00000,0xc667,0,0,0xc767,
-0,0,0xc867,0,0,0xc967,0,0,0xca67,0,0,0xcc67,0,0xe00000,0xcf67,0,
-0xe00000,0xd067,0,0xe00000,0xd267,0,0,0xd367,0,0,0xd467,0,0,0xd567,0,0,
-0xd667,0,0,0xd867,0,0,0xd967,0,0,0xda67,0,0,0xdb67,0,0,0xdc67,
-0,0,0xdd67,0,0,0xde67,0,0,0xdf67,0,0,0xe067,0,0,0xe167,0,
-0,0xe267,0,0,0xe367,0,0xe00000,0xe467,0,0,0xe567,0,0,0xe667,0,0,
-0xe767,0,0,0xe867,0,0,0xe967,0,0,0xea67,0,0,0xeb67,0,0,0xec67,
-0,0,0xed67,0,0,0xee67,0,0,0xef67,0,0,0xf167,0,0,0xf367,0,
-0,0xf567,0,0,0xf667,0,0,0xf767,0,0,0xf867,0,0,0xf967,0,0,
-0xfa67,0,0xe00000,0xfb67,0,0,0xfc67,0,0,0xfd67,0,0,0xfe67,0,0,0x10167,
-0,0,0x10267,0,0,0x10367,0,0,0x10467,0,0,0x10567,0,0xe00000,0x10667,0,
-0,0x10767,0,0,0x10867,0,0,0x10967,0,0,0x10a67,0,0,0x10b67,0,0,
-0x10c67,0,0,0x10d67,0,0,0x10e67,0,0,0x10f67,0,0,0x11067,0,0,0x11167,
-0,0,0x11367,0,0,0x11467,0,0,0x11567,0,0,0x11667,0,0,0x11767,0,
-0,0x11867,0,0,0xa0067,0,0xe00000,0xa4667,0,0xe00000,0xa4767,0,0xe00000,0xa4f67,0,0xe00000,
-0xa5e67,0,0xe00000,0xa5f67,0,0xe00000,0xac567,0,0xe00000,0xad167,0,0xe00000,0xb0067,0,0xe00000,0xb1267,
-0,0xe00000,0x11000100,0,0x900020,0x11000100,0x40000001,0x440020,0x11000100,0x40000001,0x643020,0x11000100,0x40000001,0xa5a040,0x11000100,0x40000001,
-0x116a8a0,0x11000200,0,0x900020,0x11000200,0x4000001,0xc4000b,0x11000200,0x7c00100,0x220402,0x11000200,0x24000000,0x10200000,0x11000200,0x24000008,0x1710000,
-0x11000200,0x40000001,0x1d3b020,0x11000219,0x7c00100,0x220401,0x11000219,0x7c00100,0x250401,0x11000319,0x7c00100,0x220401,0x11000319,0x7c00100,0x220402,0x11000319,
-0x7c00100,0x250400,0x11000319,0x7c00100,0x250401,0x11000419,0x7c00100,0x220400,0x11000419,0x7c00100,0x220401,0x11000419,0x7c00100,0x220402,0x11000419,0x7c00100,
-0x230400,0x11000419,0x7c00100,0x250400,0x11000419,0x7c00100,0x250401,0x11000419,0x7c00100,0x250402,0x11000519,0x7c00100,0x220400,0x11000519,0x7c00100,0x230400,
-0x11000600,0x4000400,0x200000,0x11000600,0x4000400,0x200002,0x11000600,0x4000400,0x200400,0x11000600,0x7c00500,0x220400,0x11000600,0x7c00500,0x230400,0x11000600,
-0x7c00500,0x530400,0x11000600,0x7c00d00,0x230400,0x11000619,0x7c00500,0x22040f,0x11000800,0x4000010,0x1001401,0x11000800,0x4000400,0x200001,0x11000800,0x6800010,
-0x201001,0x11000800,0x7c00500,0x230401,0x11000807,0x7c00100,0x220400,0x11000807,0x7c00100,0x250400,0x1100080e,0x4000400,0x200000,0x1100080e,0x4000400,0x200002,
-0x1100080e,0x7000500,0x220402,0x1100080e,0x7c00100,0x220400,0x1100080e,0x7c00100,0x220401,0x1100080e,0x7c00100,0x220402,0x1100080e,0x7c00100,0x250400,0x1100080e,
-0x7c00100,0x250401,0x1100080e,0x7c00120,0x220402,0x1100080e,0x7c00120,0x250402,0x11000908,0x4000000,0x200000,0x11000908,0x7c00100,0x220400,0x11000908,0x7c00100,
-0x220401,0x11000908,0x7c00100,0x250400,0x11000908,0x7c00100,0x250401,0x11000a03,0x4000000,0x200000,0x11000a03,0x4000000,0x270000,0x11000a03,0x7c00100,0x220400,
-0x11000a03,0x7c00100,0x220402,0x11000a03,0x7c00100,0x250400,0x11000a03,0x7c00500,0x230400,0x11000b13,0x2802500,0x962460,0x11000b13,0x4000000,0x200000,0x11000b13,
-0x4000000,0x201000,0x11000b13,0x4000000,0x230400,0x11000b13,0x4000002,0x400000,0x11000b13,0x4000010,0x200000,0x11000b13,0x7c00100,0x2633800,0x11000c00,0x80000000,
-0x218960,0x11000c02,0x2802100,0x962460,0x11000c02,0x2802400,0x962460,0x11000c02,0x4000000,0x200000,0x11000c02,0x4000000,0x1329400,0x11000c02,0x4000000,0x1329800,
-0x11000c02,0x4000000,0x1500000,0x11000c02,0x6800000,0x1329800,0x11000c02,0x7c00100,0x230400,0x11000c02,0x7c00100,0x230401,0x11000c02,0x7c00100,0x230402,0x11000c02,
-0x7c00500,0x230400,0x11000c02,0x7d00100,0x230400,0x11000c02,0xc000010,0xb48000,0x11000f0a,0x2802100,0x962460,0x11000f0a,0x2802400,0x962460,0x11000f0a,0x2806400,
-0x962460,0x11000f0a,0x4000000,0x200000,0x11000f0a,0x6800100,0x962540,0x11000f0a,0x7c00100,0x230400,0x11000f0a,0x7c00100,0x230401,0x11001004,0x2802100,0x962460,
-0x11001004,0x2802400,0x962460,0x11001004,0x2806400,0x962460,0x11001004,0x4000000,0x200000,0x11001004,0x4000000,0x1500000,0x11001004,0x6800100,0x962540,0x11001004,
-0x6800100,0x962541,0x11001004,0x7c00100,0x230400,0x11001004,0x7c00100,0x230401,0x11001110,0x2802100,0x962460,0x11001110,0x2802400,0x962460,0x11001110,0x2806400,
-0x962460,0x11001110,0x6800100,0x962540,0x11001110,0x7c00100,0x230400,0x11001110,0x7c00100,0x230401,0x1100120f,0x2802100,0x962460,0x1100120f,0x2802400,0x962460,
-0x1100120f,0x2806400,0x962460,0x1100120f,0x6800100,0x962540,0x1100120f,0x7c00100,0x230400,0x1100131f,0x2802100,0x962460,0x1100131f,0x2802400,0x962460,0x1100131f,
-0x2806400,0x962460,0x1100131f,0x4000000,0x200000,0x1100131f,0x6800000,0x1329800,0x1100131f,0x6800100,0x962540,0x1100131f,0x6800100,0x962541,0x1100131f,0x7c00100,
-0x230400,0x1100131f,0x7c00100,0x230401,0x11001423,0x2802100,0x962460,0x11001423,0x2806400,0x962460,0x11001423,0x6800100,0x962540,0x11001423,0x6800100,0x962541,
-0x11001423,0x7c00100,0x230400,0x11001423,0x7c00100,0x230401,0x11001524,0x2802100,0x962460,0x11001524,0x2802100,0x962461,0x11001524,0x2806400,0x962460,0x11001524,
-0x6800000,0x1329800,0x11001524,0x6800100,0x962540,0x11001524,0x7c00100,0x230400,0x11001615,0x2802100,0x962460,0x11001615,0x2806400,0x962460,0x11001615,0x6800000,
-0x1329800,0x11001615,0x6800100,0x962540,0x11001615,0x6800100,0x962541,0x11001615,0x7c00100,0x230400,0x1100171a,0x2802100,0x962460,0x1100171a,0x2806400,0x962460,
-0x1100171a,0x6800000,0x1329800,0x1100171a,0x6800100,0x962540,0x1100171a,0x6800100,0x962541,0x1100171a,0x7c00100,0x230400,0x11001900,0x4000000,0x1600000,0x11001926,
-0x2802100,0x1862460,0x11001926,0x2802400,0x1862460,0x11001926,0x2806100,0x1862460,0x11001926,0x4000000,0x200000,0x11001926,0x4000010,0x400000,0x11001926,0x6800000,
-0x1329800,0x11001926,0x7800100,0x1830142,0x11001926,0x7c00100,0x1830000,0x11001926,0x7c00900,0x1830000,0x11001926,0x7e00100,0x1830000,0x11001a18,0x2802100,0x1862460,
-0x11001a18,0x2802400,0x1862460,0x11001a18,0x6800000,0x1329800,0x11001a18,0x7800100,0x1830142,0x11001a18,0x7c00100,0x1830000,0x11001a18,0x7c00100,0x1830002,0x11001a18,
-0x7c00900,0x1830000,0x11001a18,0x7e00100,0x1830000,0x11001d0c,0x7c00100,0x230400,0x11001d0c,0x7c00100,0x250400,0x11001e12,0x7c00100,0x2230500,0x11001e12,0x7c00100,
-0x2330520,0x11001e12,0x7c80100,0x2330520,0x11002619,0x7c00100,0x220401,0x11002619,0x7c00100,0x220402,0x11002619,0x7c00100,0x250401,0x1100270e,0x4000400,0x200001,
-0x1100270e,0x4000400,0x200002,0x1100270e,0x4000400,0x500001,0x1100270e,0x7c00100,0x220401,0x1100270e,0x7c00100,0x250401,0x11002800,0x80000,0x918820,0x11002800,
-0x80000,0x1c18020,0x11002800,0x180000,0x918820,0x11002800,0x4000001,0x440001,0x11002800,0x4000001,0x440002,0x11002800,0x4000001,0xc4000b,0x11002800,0x6800000,
-0x201c00,0x11002800,0x6800020,0x201c00,0x11002800,0x24000000,0x200000,0x11002800,0x24000000,0x200002,0x11002800,0x24000000,0x810000,0x11002800,0x24000000,0x1410000,
-0x11002800,0x24000000,0x1500000,0x11002800,0x24000000,0x1500002,0x11002800,0x24000002,0x400000,0x11002800,0x24000006,0xc0000b,0x11002800,0x24000008,0x1410000,0x11002800,
-0x24000008,0x1710000,0x11002800,0x24000020,0x1001400,0x11002800,0x24000020,0x1500002,0x11002800,0x2c000010,0x1248000,0x11002800,0x2c000010,0x11248002,0x11002800,0x40000001,
-0x63b020,0x11002800,0x40080000,0x918820,0x11002801,0x80000,0x2a65620,0x11002801,0x82000,0x962460,0x11002900,0x4000000,0x20000e,0x11002900,0x4000000,0x20000f,
-0x11002900,0x4000020,0x20000e,0x11002900,0x4000020,0x20000f,0x11002900,0x4000020,0x81000e,0x11002900,0x4000020,0x81000f,0x11002900,0x4000020,0x141000e,0x11002900,
-0x4000020,0x141000f,0x11002900,0x4000022,0x20000e,0x11002900,0x4000022,0x20000f,0x11002a00,0x4000000,0x1500000,0x11002a00,0x4000000,0x1600000,0x11002a00,0x4000000,
-0x1600002,0x11002b01,0x2000,0x962460,0x11002b01,0x2802020,0x962460,0x11002c00,0x4000000,0x200000,0x11002c00,0x4000000,0x200002,0x11002c00,0x4000000,0x20000f,
-0x11002c00,0x4000020,0x200000,0x11002c00,0x7c00000,0x200000,0x11002c00,0x7c00020,0x200000,0x11002c00,0x7c00120,0x220405,0x11002c00,0x7c00120,0x230402,0x11002c00,
-0x7c00120,0x250402,0x11002c00,0x7c00120,0x250405,0x11002c19,0x7c00100,0x250400,0x11002c19,0x7c00100,0x250401,0x11002d00,0x4000000,0x100006,0x11002d00,0x4000000,
-0x200006,0x11002d19,0x7c00100,0x220402,0x11002d19,0x7c00100,0x230400,0x11002d19,0x7c00100,0x250402,0x11002e00,0x24000000,0x200000,0x11002e00,0x24000020,0x200000,
-0x11002e00,0x24000020,0x200001,0x11002e00,0x24000020,0x10200000,0x11002f00,0x24000020,0x200000,0x11002f00,0x24000020,0x200001,0x11002f00,0x24000020,0x200002,0x11002f00,
-0x24000020,0xf00000,0x11002f00,0x24000020,0x1600000,0x11002f00,0x24000022,0x1600000,0x11003000,0x24000000,0x200000,0x11003000,0x24000000,0x10200000,0x11003000,0x24000020,
-0x200000,0x11003000,0x24000020,0x810000,0x11003000,0x24000020,0x1410000,0x11003100,0x24000000,0x200000,0x11003200,0x24000000,0x200000,0x11003300,0x4000000,0x100003,
-0x11003400,0x24000000,0x100000,0x11003400,0x24000000,0x200000,0x11003500,0x24000000,0x200000,0x11003600,0x24000000,0x200000,0x11003600,0x24000000,0x10200000,0x11003600,
-0x24000020,0x200000,0x11003700,0x24000000,0x200000,0x11003700,0x24000000,0xe00000,0x11003700,0x24000000,0x10200000,0x11003700,0x24000000,0x10e00000,0x11003700,0x24000000,
-0x928045a0,0x11003700,0x24000020,0x200000,0x11003800,0x4000000,0x100000,0x11003800,0x24000000,0x200000,0x11003800,0x24000000,0xb00000,0x11003800,0x24000000,0xe00000,
-0x11003800,0x24000000,0x1710000,0x11003800,0x24000000,0x10200000,0x11003800,0x24000000,0x10b00000,0x11003800,0x24000000,0x10e00000,0x11003800,0x24000000,0x10e05200,0x11003800,
-0x24000000,0x928045a0,0x11005003,0x7c00100,0x220402,0x11005013,0x2802500,0x962460,0x11005013,0x4000020,0x200005,0x11005013,0x7c00100,0x2633801,0x11005013,0x7c00100,
-0x2633802,0x11005013,0x7c00100,0x2633805,0x11005019,0x7c00100,0x220402,0x11005100,0x24000000,0x810000,0x11005100,0x24000000,0x1410000,0x11005102,0x7000100,0x230408,
-0x11005102,0x7c00100,0x230404,0x11005102,0x7c00100,0x230407,0x11005102,0x7c00100,0x230408,0x11005102,0x7c00100,0x230409,0x11005201,0x2802400,0x962460,0x11005500,
-0x80000,0x1e18820,0x11005502,0x7000100,0x230408,0x11005502,0x7c00100,0x230404,0x11005502,0x7c00100,0x230407,0x11005502,0x7c00100,0x230408,0x11005502,0x7c00100,
-0x230409,0x11005667,0x1000,0,0x11020200,0x80004,0x418820,0x11020200,0x4000000,0x100006,0x11020200,0x4000000,0x10000f,0x11020200,0x4000400,0x100002,
-0x11020200,0x4000400,0x500002,0x11020200,0x6800c00,0x101000,0x11020200,0x24000000,0x100000,0x11020200,0x24000000,0x1400000,0x11020200,0x24000000,0x1500000,0x11020200,
-0x24000000,0x1600000,0x11020200,0x24000000,0x10200000,0x11020200,0x24000020,0x100000,0x11020200,0x24000020,0x1600000,0x11020219,0x7c00100,0x12040f,0x11020219,0x7c00100,
-0x220400,0x11020219,0x7c00100,0x220401,0x11020219,0x7c00100,0x250400,0x11020319,0x7c00100,0x220400,0x11020319,0x7c00100,0x220401,0x11020319,0x7c00100,0x220402,
-0x11020319,0x7c00100,0x250400,0x11020319,0x7c00100,0x250402,0x11020319,0x7d00100,0x220402,0x11020419,0x7c00100,0x220401,0x11020519,0x7c00100,0x220400,0x11020600,
-0x4000400,0x100002,0x11020600,0x4000400,0x200400,0x11020600,0x7c00500,0x130400,0x11020600,0x7c00d00,0x130400,0x11020701,0x2802400,0x962460,0x11020701,0x2802400,
-0x962461,0x11020701,0x2802400,0xc62460,0x1102080e,0x7c00100,0x220400,0x1102080e,0x7c00100,0x250400,0x11020908,0x7c00100,0x220400,0x11020908,0x7c00100,0x220401,
-0x11020908,0x7c00100,0x250400,0x11020908,0x7c00100,0x250401,0x11022800,0x24000000,0x100000,0x11022800,0x24000000,0x200000,0x11022800,0x24000000,0x200002,0x11022800,
-0x24000000,0x401000,0x11022800,0x24000000,0xf00002,0x11022800,0x24000000,0xf0ac02,0x11022800,0x24000000,0x1500000,0x11022800,0x24000002,0x100000,0x11022800,0x24000002,
-0x370000,0x11022800,0x24000002,0x470000,0x11022800,0x24000006,0x400000,0x11022800,0x24000008,0x1710000,0x11022800,0x24000008,0x1712c00,0x11022800,0x24000020,0x100000,
-0x11022800,0x24000020,0x1500000,0x11022800,0x24000020,0x1500002,0x11022900,0x4000000,0x10000e,0x11022900,0x4000000,0x10000f,0x11022919,0x7c00100,0x12040f,0x11022c00,
-0x4000000,0x100002,0x11022c00,0x4000000,0x1500002,0x11022c00,0x4000000,0x1600002,0x11022c00,0x4000000,0x1010000f,0x11022c00,0x7c00120,0x120405,0x11022c0e,0x7c00100,
-0x250401,0x11022c19,0x7c00100,0x150401,0x11022d00,0x4000000,0x100006,0x11022d00,0x4000000,0x200006,0x11022d19,0x7c00100,0x120402,0x11022d19,0x7c00100,0x150402,
-0x11022e00,0x24000000,0x200000,0x11022e00,0x24000020,0x100000,0x11022e00,0x24000020,0x10100000,0x11022f00,0x24000020,0x100000,0x11022f00,0x24000020,0x100001,0x11022f00,
-0x24000020,0x100002,0x11023000,0x24000000,0x100000,0x11023300,0x4000000,0x100002,0x11023300,0x4000000,0x100003,0x11023300,0x4000100,0x120403,0x11023300,0x4000100,
-0x150403,0x11023300,0x4000100,0x10150403,0x11023400,0x24000000,0x100000,0x11023500,0x24000000,0x100000,0x11023600,0x24000000,0x100000,0x11023600,0x24000020,0x100000,
-0x11023600,0x24000020,0x10100000,0x11023700,0x24000000,0x100000,0x11023700,0x24000000,0xe00000,0x11023700,0x24000000,0x10100000,0x11023700,0x24000000,0x10e00000,0x11023700,
-0x24000020,0x100000,0x11023700,0x24000020,0x10100000,0x11023700,0x24000020,0x10105200,0x11023800,0x4000000,0x100000,0x11023800,0x24000000,0x200000,0x11024e67,0,
-0,0x11025600,0x4000000,0x100000,0x11042a00,0x4000000,0x1600000,0x11045700,0x4000000,0x20000a,0x11045700,0x4000020,0x20000a,0x11045712,0x7c00100,0xe3040a,
-0x11045712,0x7c80100,0xe3040a,0x11045716,0x7c00100,0xe30c0a,0x11045716,0x7c00100,0x2530c0a,0x11063d00,0x4000001,0x440011,0x11065700,0x4000000,0x810011,0x11065700,
-0x4000000,0xe00011,0x11065700,0x4000000,0x1410011,0x11065700,0x4000000,0x1500011,0x11065700,0x4000000,0x1600011,0x11065700,0x4000006,0xe70011,0x11065700,0x4000008,
-0xe00011,0x11065700,0x4000008,0xe02c11,0x11065700,0x4000010,0x871411,0x11065700,0x4000010,0x1201411,0x11065700,0x4000010,0x1271011,0x11065700,0x4000020,0xe00011,
-0x11065700,0x4000400,0xe00011,0x11065700,0x4000420,0xe00011,0x11065700,0x6800000,0xe01c11,0x11065700,0x6800040,0xe00011,0x11065700,0xc000010,0x80ac11,0x11065700,
-0xc000010,0xb48011,0x11065719,0x7c00100,0xe20411,0x11065719,0x7c00100,0xe50411,0x11065719,0x7c00140,0xe20411,0x11065719,0x7c00140,0xe50411,0x11080100,0x6800000,
-0x201c00,0x11080100,0x68000c0,0x19329800,0x11080100,0x24000000,0x200000,0x11080100,0x24000000,0x810000,0x11080100,0x24000000,0x1410000,0x11080100,0x24000000,0x1500000,
-0x11080100,0x24000000,0x1600000,0x11080100,0x24000000,0x1b00000,0x11080100,0x24000000,0x2410000,0x11080100,0x24000000,0x18200000,0x11080100,0x24000006,0xd70000,0x11080100,
-0x24000008,0x1713c00,0x11080100,0x24000008,0x1714000,0x11080100,0x24000010,0x1001400,0x11080100,0x24000010,0x1071000,0x11080100,0x24000010,0x1071400,0x11080100,0x24000020,
-0x200000,0x11080100,0x24000020,0x400000,0x11080100,0x24000020,0x1600000,0x11080100,0x24000400,0x200000,0x11080100,0x24000420,0x200000,0x11080100,0x2c000010,0xb48000,
-0x11080100,0x2c000010,0x100ac00,0x11080100,0x44000001,0x1a40000,0x11080119,0x7c00100,0x220400,0x11080119,0x7c00100,0x250400,0x11080119,0x7c001c0,0x220400,0x11080119,
-0x7c001c0,0x250400,0x11080200,0x4000400,0x200002,0x11080200,0x24000000,0x200000,0x11080200,0x24000000,0x1500000,0x11080200,0x24000000,0x1600000,0x11080200,0x24000020,
-0x200000,0x110a1e12,0x7c00100,0x2130480,0x110a1e12,0x7c80100,0x2130480,0x110a3000,0x24000000,0x30e00000,0x110a3000,0x24100000,0x810001,0x110a3000,0x24100000,0x1410001,
-0x110a3700,0x24000000,0x30200000,0x110a3d00,0x4000000,0xe00000,0x110a3d00,0x4000000,0xe00002,0x110a3d00,0x24000000,0xe00000,0x110a3d11,0x7c00300,0xe30000,0x110a3d11,
-0x7c00900,0x1230400,0x110a3d12,0x2802400,0x962460,0x110a3e14,0x7c00100,0xe30000,0x110a3e14,0x7c00100,0xe30001,0x110a3e14,0x7c00100,0x2530000,0x110a3e14,0x7c00900,
-0x1230000,0x110a3e14,0x7c00900,0x1230001,0x110a3f16,0x7c00100,0xe30c00,0x110a3f16,0x7c00100,0xe30c01,0x110a3f16,0x7c00100,0x2530c00,0x110a3f16,0x7c00900,0x1230c00,
-0x110a3f16,0x7c00900,0x1230c01,0x110a4005,0x7c00100,0xe30400,0x110a4112,0x7c00100,0xe30402,0x110a4112,0x7c80100,0xe30402,0x110a4400,0x4000000,0xe00000,0x110a4412,
-0x4000000,0xe00002,0x110a4412,0x4000000,0xe00003,0x110a4416,0x4000000,0xe00c03,0x110a4500,0x4000000,0xe0000d,0x110a4516,0x4000000,0xe00c0d,0x110a4711,0x7c40300,
-0xe30000,0x110a4f11,0x7c00300,0xe30001,0x110a4f11,0x7c40300,0xe30000,0x110a5300,0x4000000,0x810010,0x110a5300,0x4000000,0xe00002,0x110a5300,0x4000000,0xe00010,
-0x110a5300,0x4000000,0x1410010,0x110a5300,0x4000002,0xe70010,0x110a5300,0x4000008,0x810010,0x110a5300,0x4000008,0x1410010,0x110a5300,0x6800000,0xe01c02,0x110a5300,
-0x6800000,0xe01c10,0x110a5400,0x4000000,0x81000c,0x110a5400,0x4000000,0xe0000c,0x110a5400,0x4000000,0x141000c,0x110a5400,0x4000000,0x150000c,0x110a5400,0x4000000,
-0x160000c,0x110a5400,0x4000002,0xe7000c,0x110a5400,0x4000010,0x87140c,0x110a5400,0x4000010,0xe7000c,0x110a5400,0x4000010,0x120140c,0x110a5400,0x4000010,0x127100c,
-0x110a5400,0x4000020,0xe0000c,0x110a5400,0x4000026,0xe7000c,0x110a5400,0xc000010,0x80ac0c,0x110a5400,0xc000010,0xb4800c,0x11400a0c,0xc000010,0x1049400,0x11400c0e,
-0x4000010,0xb00000,0x11400c0e,0x4000010,0x1071400,0x11400c0e,0xc000010,0xb48000,0x11400c13,0x7c00900,0x230400,0x11400f36,0xc000010,0x448000,0x11400f46,0xc000010,
-0x448000,0x11401d72,0x4000000,0x200000,0x11403d95,0x4000000,0xe00000,0x1144578a,0x4000004,0x120000a,0x1144578a,0x4000008,0x81000a,0x1144578a,0x4000008,0x141000a,
-0x1144578a,0x4000010,0x87000a,0x1144578a,0xc000010,0x84800a,0x11445793,0x3802500,0x126246a,0x11445793,0x7c00d00,0x2530c0a,0x114a3d8a,0x24000000,0x810000,0x114a3d8a,
-0x24000000,0x1410000,0x114a3d8a,0x24000008,0x810000,0x114a3d8a,0x24000008,0x1410000,0x114a3d8a,0x24000010,0x870000,0x114a3d8a,0x2c000010,0x848000,0x114a3d90,0x4000000,
-0xe00000,0x114a3d90,0x24000000,0xe00000,0x114a3d90,0x24000002,0x1200000,0x114a3d90,0x24000002,0x10e00000,0x114a3d90,0x24000008,0x810000,0x114a3d90,0x24000008,0x1410000,
-0x114a3d93,0x7c00900,0x930c00,0x114a3d93,0x7c00900,0xe30c00,0x114a3d95,0x7c00300,0xe30000,0x114a3e93,0x7000400,0x1200c02,0x114a3f8a,0x4000004,0x1200000,0x114a3f93,
-0x7c00d00,0x2530c00,0x114a4295,0x4000000,0xe00000,0x114a4295,0x4000000,0xe0000f,0x114a4495,0x4000000,0xe00002,0x114a4495,0x4000000,0xe00003,0x114a4495,0x4000000,
-0x10e00003,0x114a4595,0x4000000,0xe00002,0x114a4595,0x4000000,0xe0000d,0x1180090a,0x2802400,0x962460,0x11800c19,0x2802100,0x962460,0x11800c19,0x2802500,0x962460,
-0x11800f1f,0x2802400,0x962460,0x11800f2b,0x2802400,0x962460,0x11820700,0x2802400,0x962460,0x11820700,0x2802500,0x962460,0x118a3d96,0x2802400,0x962460,0x118a3e93,
-0x2802400,0x962460,0x11c00904,0x2802400,0x962460,0x11c00908,0x2802400,0x962460,0x11c00c1d,0x6800000,0x1329800,0x11c00f5a,0x6800000,0x1329800,0x11c0105f,0x6800000,
-0x1329800,0x11c01163,0x6800000,0x1329800,0x11c01267,0x6800000,0x1329800,0x11c0146b,0x4000000,0x200000,0x11c0146b,0x6800000,0x1329800,0x11c0146b,0x7c00100,0x230400,
-0x11c0511d,0x7c00100,0x230408,0x20000067,0x1000,0,0x20000b13,0x2802400,0x962460,0x20000b13,0x2802500,0x962460,0x20001b27,0x2802100,0x962460,0x20001b27,
-0x2802100,0x962461,0x20001b27,0x2802400,0x962460,0x20001b27,0x2806400,0x962460,0x20001b27,0x2902100,0x962462,0x20001b27,0x4000000,0x200000,0x20001b27,0x4000000,
-0x400000,0x20001b27,0x4000000,0x500000,0x20001b27,0x4000000,0x810000,0x20001b27,0x4000000,0xb00000,0x20001b27,0x4000000,0xc0000b,0x20001b27,0x4000000,0x1410000,
-0x20001b27,0x4000010,0xb00000,0x20001b27,0x4000010,0xc00000,0x20001b27,0x6800000,0x1329800,0x20001b27,0x6800100,0x462540,0x20001b27,0x6800400,0x962540,0x20001b27,
-0x7c00100,0x230400,0x20001b27,0x7c00100,0x230401,0x20002619,0x7c00100,0x220401,0x20002a00,0x4000000,0x1600000,0x20004b67,0,0x1900020,0x20004c67,0,
-0x1900020,0x20004d67,0,0x1900020,0x20006d67,0x1000,0,0x20006e67,0x1000,0,0x20026d67,0,0,0x20026e67,0,0,
-0x200a4a12,0x7c00100,0x1f304c1,0x200a4a12,0x7c00100,0x20304e1,0x21005600,0x4000000,0x700000,0x21022a00,0x4000000,0x1600000,0x30000419,0x7c00100,0x220400,0x30000419,
-0x7c00100,0x220401,0x30000419,0x7c00100,0x250400,0x30000419,0x7c00100,0x250401,0x30000519,0x7c00100,0x220400,0x30000600,0x4000400,0x200400,0x30000600,0x7c00500,
-0x230400,0x30000605,0x4000400,0x200000,0x3000080e,0x7c00100,0x220400,0x30000908,0x2000,0x962460,0x30000908,0x7c00100,0x220400,0x30000908,0x7c00100,0x220401,
-0x30000908,0x7c00100,0x250400,0x30000908,0x7c00100,0x250401,0x30000a03,0x4000006,0x400000,0x30000c02,0x4000000,0x200000,0x30000c02,0x7c00100,0x230400,0x30000d22,
-0x2802100,0x962460,0x30000d22,0x2802400,0x962460,0x30000d22,0x2802500,0x962460,0x30000d22,0x4000000,0x200000,0x30000d22,0x4000010,0x200000,0x30000d22,0x7c00100,
-0x230400,0x30000d22,0xc000010,0x248000,0x30000d22,0x80000000,0x218960,0x30000e25,0x2802500,0x962460,0x30000e25,0x7c00100,0x230400,0x30001821,0x2802100,0x962460,
-0x30001821,0x2806400,0x962460,0x30001821,0x4000000,0x200000,0x30001821,0x6800100,0x962540,0x30001821,0x6800100,0x962541,0x30001821,0x7c00100,0x230400,0x30001b27,
-0x2802100,0x962460,0x30001b27,0x2802400,0x962460,0x30001b27,0x4000000,0x200000,0x30001b27,0x4000000,0x400000,0x30001b27,0x7c00100,0x230400,0x30001c1c,0x2802100,
-0x1862460,0x30001c1c,0x2802400,0x1862460,0x30001c1c,0x2806400,0x1862460,0x30001c1c,0x4000000,0x200000,0x30001c1c,0x6800100,0x1862400,0x30001c1c,0x6800100,0x1862540,
-0x30001c1c,0x7c00100,0x1830000,0x30001c1c,0x7c00100,0x1830001,0x30001c1c,0xc000010,0x448000,0x30001f0b,0x4000000,0x200000,0x30001f0b,0x4000010,0x200000,0x30001f0b,
-0x4000010,0x400000,0x30001f0b,0x6800000,0x200000,0x30001f0b,0x7c00100,0x230400,0x30001f0b,0xc000010,0x248000,0x30002006,0x7c00100,0x250400,0x30002128,0x4000010,
-0x200000,0x30002128,0x7c00100,0x230400,0x30002128,0xc000010,0x248000,0x3000221d,0x4000000,0x810000,0x3000221d,0x4000000,0x1410000,0x3000221d,0x4000001,0x440000,
-0x3000221d,0x7c00100,0x230400,0x30002300,0x4000010,0x400000,0x30002320,0x7c00100,0x230400,0x30002417,0x2802100,0x1862460,0x30002417,0x2802400,0x1862460,0x30002417,
-0x2806400,0x1862460,0x30002417,0x2882000,0x1862460,0x30002417,0x4000000,0x200000,0x30002417,0x4000000,0x400000,0x30002417,0x4000000,0x1600000,0x30002417,0x4000010,
-0x400000,0x30002417,0x4000010,0x1200000,0x30002417,0x6800000,0x1329800,0x30002417,0x6800100,0x1862540,0x30002417,0x7c00100,0x1830000,0x30002417,0x7d00100,0x1830000,
-0x3000251b,0x80000,0xc18820,0x3000251b,0x2802100,0x962460,0x3000251b,0x3c02100,0x962460,0x3000251b,0x4000000,0x200000,0x3000251b,0x4000006,0x500000,0x3000251b,
-0x4000010,0x400000,0x3000251b,0x4000010,0xb70000,0x3000251b,0x4000800,0x200000,0x3000251b,0x6800000,0x1329800,0x3000251b,0x7c00100,0x230400,0x3000251b,0x7c00900,
-0x230400,0x3000251b,0xc000010,0xb48000,0x3000251b,0x12882000,0x962460,0x30002800,0x4000001,0xc41c0b,0x30002800,0x24000000,0x200000,0x30002800,0x2c000010,0x1248002,
-0x30002800,0x2c000010,0x11248002,0x30002a00,0x4000000,0x1600000,0x30002b01,0x2000,0x962460,0x30002c00,0x4000000,0x200000,0x30002c00,0x7c00100,0x10220405,0x30002d19,
-0x7c00100,0x250400,0x30002e00,0x24000000,0x200000,0x30003000,0x24000000,0x200000,0x30003100,0x24000000,0x200000,0x30003600,0x24000000,0x200000,0x30003700,0x24000000,
-0x200000,0x3000392e,0x24000000,0x200000,0x30005013,0x7c00100,0x2633801,0x30005600,0,0x918820,0x30020600,0x4000400,0x500400,0x30020701,0x2802400,0x962460,
-0x30020701,0x2802400,0xc62460,0x300a3a11,0x4020000,0xe00000,0x300a3a11,0x4020000,0xe00002,0x300a3b11,0x4020000,0xe00002,0x300a3c00,0x4008000,0xe00000,0x300a3c00,
-0x4010000,0xe00000,0x300a3d11,0x7c00300,0xe30002,0x300a4305,0x7c00100,0xe30400,0x300a4611,0x7c40300,0xe30000,0x300a4829,0x7c00100,0xe30400,0x300a4829,0x7c00900,
-0x1230400,0x300a4929,0x4000000,0xe00000,0x30402578,0x4000010,0x400000,0x30402578,0x4000010,0xb70000,0x30402578,0xc000010,0xb48000,0x304a3d95,0x4000000,0xe00000,
-0x30800c19,0x2802100,0x962460,0x30c01c70,0x6800000,0x1329800,0x3100080e,0x7c00120,0x220402,0x3100080e,0x7c00120,0x250402,0x31005167,0x1000,0,0x3100581e,
-0x4000000,0x200000,0x3100581e,0x7c00100,0x230400,0x3100590d,0x7c00100,0x230400,0x31005a09,0x7c00100,0x220400,0x31005a09,0x7c00100,0x250400,0x31005b00,0x4000000,
-0x200000,0x31005c00,0x80000,0x918820,0x31005c00,0x2802000,0x962460,0x31005c00,0x2802400,0x962460,0x31005c00,0x4000000,0x200000,0x31005c00,0x4000000,0x200001,
-0x31005c00,0x6800000,0x962540,0x31005c00,0x6800400,0x962540,0x31005c01,0x2802400,0x962460,0x31005d00,0x4000020,0x200005,0x31005d00,0x6800020,0x1329805,0x31005d00,
-0x7c00120,0x220405,0x31005d00,0x7c00120,0x250405,0x31006000,0x82000,0x962460,0x31006000,0x180000,0x918820,0x310a5e11,0x7c40300,0xe30000,0x310a5f11,0x7c00300,
-0xe30001,0x32000419,0x7c00100,0x250400,0x3200080e,0x4000020,0x200000,0x3200080e,0x7c00100,0x220400,0x3200080e,0x7c00100,0x250400,0x32000908,0x7c00100,0x220400,
-0x32000908,0x7c00100,0x250400,0x32000c02,0x7c00100,0x230400,0x32000e25,0x7c00100,0x230400,0x32001d0c,0x7c00100,0x230400,0x32002800,0x80000,0x1e18820,0x32002800,
-0x80020,0x218820,0x32002800,0x4000001,0x440002,0x32002800,0x24000000,0x200000,0x32002800,0x24000000,0x200002,0x32002800,0x24000020,0x200000,0x32002800,0x2c000010,
-0x1248002,0x32002919,0x7c00100,0x22040f,0x32002a00,0x4000000,0x1600000,0x32002b01,0x2000,0x962460,0x32002b01,0x2802000,0x962460,0x32002b01,0x2802020,0x962460,
-0x32002c00,0x4000000,0x200000,0x32002c00,0x4000020,0x200000,0x32002c00,0x4000020,0x200005,0x32002c00,0x7c00120,0x220405,0x32002c00,0x7c00120,0x250405,0x32002e00,
-0x24000020,0x200000,0x32002f00,0x24000020,0x200000,0x32003000,0x24000000,0x200000,0x32003000,0x24000020,0x200000,0x32003500,0x24000000,0x200000,0x32003600,0x24000020,
-0x200000,0x32003600,0x24000020,0x10200000,0x32003700,0x24000000,0x100000,0x32003700,0x24000000,0x200000,0x32003700,0x24000000,0x10200000,0x32003800,0x24000000,0x810000,
-0x32003800,0x24000000,0x1410000,0x32005102,0x4000000,0x1500008,0x32005502,0x7c00100,0x230400,0x32006108,0x7c00100,0x220400,0x32006108,0x7c00100,0x250400,0x3200622a,
-0x2802100,0x962460,0x3200622a,0x2806000,0x962460,0x3200622a,0x7c00100,0x230400,0x3200632b,0x2802100,0x962460,0x3200632b,0x2806000,0x962460,0x3200632b,0x7c00100,
-0x230400,0x3200642c,0x2802100,0x962460,0x3200642c,0x7c00100,0x230400,0x3200652d,0x2802100,0x962460,0x3200652d,0x7c00100,0x230400,0x32006600,0x24000020,0x200000,
-0x32006700,0x24000020,0x200000,0x32006800,0x24000020,0x200000,0x32006800,0x24000020,0x10200000,0x32006900,0x24000020,0x200000,0x32006900,0x24000020,0x810000,0x32006900,
-0x24000020,0x1410000,0x32006a00,0x24000020,0x200000,0x32006a00,0x24000020,0x200001,0x32006a00,0x24000020,0x200002,0x32020701,0x2882000,0xc62460,0x32023300,0x4000000,
-0x100000,0x32026c01,0x12882000,0x962460,0x32065700,0x4000000,0x810011,0x32065700,0x4000000,0x1410011,0x32086600,0x24000020,0x810000,0x32086600,0x24000020,0x1410000,
-0x32086900,0x24000020,0x810000,0x32086900,0x24000020,0x1410000,0x320a3600,0x24000020,0x30200000,0x320a3d11,0x7c00100,0x1230400,0x320a3e14,0x7c00100,0xe30010,0x320a3e14,
-0x7c00100,0x2530000,0x320a3f16,0x7c00100,0xe30c10,0x320a4400,0x4000000,0xe00003,0x320a4929,0x4000000,0xe00000,0x320a4f11,0x7c00300,0xe30001,0x320a6b16,0x7c00100,
-0x2530c00,0x32406374,0xc000010,0x448000,0x324a3d98,0x4000000,0x10e00000,0x324a3d98,0x7c00100,0x1230400,0x324a3f93,0x4000002,0x1200c00,0x324a5390,0x24000000,0xe00000,
-0x32820701,0x2802000,0x962460,0x40000419,0x7c00100,0x220400,0x40000519,0x7c00100,0x220400,0x40000600,0x4000400,0x200400,0x4000080e,0x7c00100,0x220400,0x4000080e,
-0x7c00100,0x250400,0x4000080e,0x7c00100,0x250402,0x40000c02,0x2802100,0x962460,0x40000c02,0x2802400,0x962460,0x40000c02,0x2802500,0x962460,0x40000c02,0x4000000,
-0x200000,0x40000c02,0x4000000,0x1071400,0x40000c02,0x7c00100,0x230400,0x40000c02,0x80000000,0x218960,0x40000d22,0x7c00100,0x230400,0x40000f0a,0x7c00100,0x230400,
-0x40001004,0x7c00100,0x230400,0x40001110,0x2802100,0x962460,0x40001110,0x6800100,0x962540,0x4000120f,0x2802100,0x962460,0x4000120f,0x4000000,0x1600000,0x4000120f,
-0x7c00100,0x230400,0x4000131f,0x7c00100,0x230400,0x40001423,0x4000000,0x200000,0x40001423,0x4000000,0x1600000,0x40001615,0x2802400,0x962460,0x40001615,0x7c00100,
-0x230400,0x40002417,0x2802400,0x1862460,0x40002417,0x4000000,0x200000,0x40002800,0x6800000,0x201c00,0x40002800,0x24000002,0x200000,0x40002c00,0x4000000,0x200002,
-0x40003000,0x24000000,0x10200000,0x40003000,0x24000020,0x200000,0x40003700,0x24000000,0x200000,0x40003700,0x24000000,0x10200000,0x40005a09,0x7c00100,0x220400,0x40005a09,
+0,0xa967,0,0,0xaa67,0,0x4e00000,0xab67,0,0x4e00000,0xac67,0,0,0xad67,0,0,
+0xae67,0,0,0xaf67,0,0,0xb167,0,0,0xb267,0,0,0xb467,0,0,0xb567,
+0,0,0xb767,0,0,0xb867,0,0,0xb967,0,0,0xba67,0,0,0xbc67,0,
+0,0xbd67,0,0,0xbe67,0,0,0xbf67,0,0,0xc067,0,0,0xc167,0,0,
+0xc267,0,0,0xc367,0,0x4e00000,0xc467,0,0x4e00000,0xc667,0,0,0xc767,0,0,0xc867,
+0,0,0xc967,0,0,0xca67,0,0,0xcc67,0,0x4e00000,0xcf67,0,0x4e00000,0xd067,0,
+0x4e00000,0xd267,0,0,0xd367,0,0,0xd467,0,0,0xd567,0,0,0xd667,0,0,
+0xd867,0,0,0xd967,0,0,0xda67,0,0,0xdb67,0,0,0xdc67,0,0,0xdd67,
+0,0,0xde67,0,0,0xdf67,0,0,0xe067,0,0,0xe167,0,0,0xe267,0,
+0,0xe367,0,0x4e00000,0xe467,0,0,0xe567,0,0,0xe667,0,0,0xe767,0,0,
+0xe867,0,0,0xe967,0,0,0xea67,0,0,0xeb67,0,0,0xec67,0,0,0xed67,
+0,0,0xee67,0,0,0xef67,0,0,0xf167,0,0,0xf367,0,0,0xf567,0,
+0,0xf667,0,0,0xf767,0,0,0xf867,0,0,0xf967,0,0,0xfa67,0,0x4e00000,
+0xfb67,0,0,0xfc67,0,0,0xfd67,0,0,0xfe67,0,0,0x10167,0,0,0x10267,
+0,0,0x10367,0,0,0x10467,0,0,0x10567,0,0x4e00000,0x10667,0,0,0x10767,0,
+0,0x10867,0,0,0x10967,0,0,0x10a67,0,0,0x10b67,0,0,0x10c67,0,0,
+0x10d67,0,0,0x10e67,0,0,0x10f67,0,0,0x11067,0,0,0x11167,0,0,0x11367,
+0,0,0x11467,0,0,0x11567,0,0,0x11667,0,0,0x11767,0,0,0x11867,0,
+0,0x11967,0,0x4e00000,0x11a67,0,0,0x11b67,0,0,0x11c67,0,0,0x11d67,0,0,
+0x11e67,0,0,0x11f67,0,0,0x12067,0,0,0x12167,0,0,0x12267,0,0,0x12367,
+0,0,0xa0067,0,0xe00000,0xa4667,0,0xe00000,0xa4767,0,0xe00000,0xa4f67,0,0xe00000,0xa5e67,0,
+0xe00000,0xa5f67,0,0xe00000,0xac567,0,0xe00000,0xad167,0,0xe00000,0xb0067,0,0xe00000,0xb1267,0,0xe00000,
+0x11000100,0,0x900020,0x11000100,0x40000001,0x440020,0x11000100,0x40000001,0x643020,0x11000100,0x40000001,0xa5a040,0x11000100,0x40000001,0x116a8a0,0x11000200,
+0,0x900020,0x11000200,0x4000001,0xc4000b,0x11000200,0x7c00100,0x220402,0x11000200,0x24000000,0x14200000,0x11000200,0x24000008,0x1710000,0x11000200,0x40000001,
+0x1d3b020,0x11000219,0x7c00100,0x220401,0x11000219,0x7c00100,0x250401,0x11000319,0x7c00100,0x220401,0x11000319,0x7c00100,0x220402,0x11000319,0x7c00100,0x250400,
+0x11000319,0x7c00100,0x250401,0x11000419,0x7c00100,0x220400,0x11000419,0x7c00100,0x220401,0x11000419,0x7c00100,0x220402,0x11000419,0x7c00100,0x230400,0x11000419,
+0x7c00100,0x250400,0x11000419,0x7c00100,0x250401,0x11000419,0x7c00100,0x250402,0x11000519,0x7c00100,0x220400,0x11000519,0x7c00100,0x230400,0x11000600,0x4000400,
+0x200000,0x11000600,0x4000400,0x200002,0x11000600,0x4000400,0x200400,0x11000600,0x7c00500,0x220400,0x11000600,0x7c00500,0x230400,0x11000600,0x7c00500,0x530400,
+0x11000600,0x7c00d00,0x230400,0x11000619,0x7c00500,0x22040f,0x11000800,0x4000010,0x1001401,0x11000800,0x4000400,0x200001,0x11000800,0x6800010,0x201001,0x11000800,
+0x7c00500,0x230401,0x11000807,0x7c00100,0x220400,0x11000807,0x7c00100,0x250400,0x1100080e,0x4000400,0x200000,0x1100080e,0x4000400,0x200002,0x1100080e,0x7000500,
+0x220402,0x1100080e,0x7c00100,0x220400,0x1100080e,0x7c00100,0x220401,0x1100080e,0x7c00100,0x220402,0x1100080e,0x7c00100,0x250400,0x1100080e,0x7c00100,0x250401,
+0x1100080e,0x7c00120,0x220402,0x1100080e,0x7c00120,0x250402,0x11000908,0x4000000,0x200000,0x11000908,0x7c00100,0x220400,0x11000908,0x7c00100,0x220401,0x11000908,
+0x7c00100,0x250400,0x11000908,0x7c00100,0x250401,0x11000a03,0x4000000,0x200000,0x11000a03,0x4000000,0x200400,0x11000a03,0x4000000,0x270000,0x11000a03,0x7c00100,
+0x220400,0x11000a03,0x7c00100,0x220402,0x11000a03,0x7c00100,0x250400,0x11000a03,0x7c00500,0x230400,0x11000b13,0x2802500,0x962460,0x11000b13,0x4000000,0x200000,
+0x11000b13,0x4000000,0x201000,0x11000b13,0x4000000,0x230400,0x11000b13,0x4000002,0x400000,0x11000b13,0x4000010,0x200000,0x11000b13,0x7c00100,0x2633800,0x11000c00,
+0x80000000,0x218960,0x11000c02,0x2802100,0x962460,0x11000c02,0x2802400,0x962460,0x11000c02,0x4000000,0x200000,0x11000c02,0x4000000,0x1329400,0x11000c02,0x4000000,
+0x1329800,0x11000c02,0x4000000,0x1500000,0x11000c02,0x6800000,0x1329800,0x11000c02,0x7c00100,0x230400,0x11000c02,0x7c00100,0x230401,0x11000c02,0x7c00100,0x230402,
+0x11000c02,0x7c00500,0x230400,0x11000c02,0x7d00100,0x230400,0x11000f0a,0x2802100,0x962460,0x11000f0a,0x2802400,0x962460,0x11000f0a,0x2806400,0x962460,0x11000f0a,
+0x4000000,0x200000,0x11000f0a,0x6800100,0x962540,0x11000f0a,0x7c00100,0x230400,0x11000f0a,0x7c00100,0x230401,0x11001004,0x2802100,0x962460,0x11001004,0x2802400,
+0x962460,0x11001004,0x2806400,0x962460,0x11001004,0x4000000,0x200000,0x11001004,0x4000000,0x1500000,0x11001004,0x6800100,0x962540,0x11001004,0x6800100,0x962541,
+0x11001004,0x7c00100,0x230400,0x11001004,0x7c00100,0x230401,0x11001110,0x2802100,0x962460,0x11001110,0x2802400,0x962460,0x11001110,0x2806400,0x962460,0x11001110,
+0x6800100,0x962540,0x11001110,0x7c00100,0x230400,0x11001110,0x7c00100,0x230401,0x1100120f,0x2802100,0x962460,0x1100120f,0x2802400,0x962460,0x1100120f,0x2806400,
+0x962460,0x1100120f,0x6800100,0x962540,0x1100120f,0x7c00100,0x230400,0x1100131f,0x2802100,0x962460,0x1100131f,0x2802400,0x962460,0x1100131f,0x2806400,0x962460,
+0x1100131f,0x4000000,0x200000,0x1100131f,0x6800000,0x1329800,0x1100131f,0x6800100,0x962540,0x1100131f,0x6800100,0x962541,0x1100131f,0x7c00100,0x230400,0x1100131f,
+0x7c00100,0x230401,0x11001423,0x2802100,0x962460,0x11001423,0x2806400,0x962460,0x11001423,0x6800100,0x962540,0x11001423,0x6800100,0x962541,0x11001423,0x7c00100,
+0x230400,0x11001423,0x7c00100,0x230401,0x11001524,0x2802100,0x962460,0x11001524,0x2802100,0x962461,0x11001524,0x2806400,0x962460,0x11001524,0x6800000,0x1329800,
+0x11001524,0x6800100,0x962540,0x11001524,0x7c00100,0x230400,0x11001615,0x2802100,0x962460,0x11001615,0x2806400,0x962460,0x11001615,0x6800000,0x1329800,0x11001615,
+0x6800100,0x962540,0x11001615,0x6800100,0x962541,0x11001615,0x7c00100,0x230400,0x1100171a,0x2802100,0x962460,0x1100171a,0x2806400,0x962460,0x1100171a,0x6800000,
+0x1329800,0x1100171a,0x6800100,0x962540,0x1100171a,0x6800100,0x962541,0x1100171a,0x7c00100,0x230400,0x11001900,0x4000000,0x1600000,0x11001926,0x2802100,0x1862460,
+0x11001926,0x2802400,0x1862460,0x11001926,0x2806100,0x1862460,0x11001926,0x4000000,0x200000,0x11001926,0x4000010,0x400000,0x11001926,0x6800000,0x1329800,0x11001926,
+0x7800100,0x1830142,0x11001926,0x7c00100,0x1830000,0x11001926,0x7c00900,0x1830000,0x11001926,0x7e00100,0x1830000,0x11001a18,0x2802100,0x1862460,0x11001a18,0x2802400,
+0x1862460,0x11001a18,0x6800000,0x1329800,0x11001a18,0x7800100,0x1830142,0x11001a18,0x7c00100,0x1830000,0x11001a18,0x7c00100,0x1830002,0x11001a18,0x7c00900,0x1830000,
+0x11001a18,0x7e00100,0x1830000,0x11001d0c,0x7c00100,0x220400,0x11001d0c,0x7c00100,0x250400,0x11001e12,0x7c00100,0x2230500,0x11001e12,0x7c00100,0x2330520,0x11001e12,
+0x7c80100,0x2330520,0x11002619,0x7c00100,0x220401,0x11002619,0x7c00100,0x220402,0x11002619,0x7c00100,0x250401,0x1100270e,0x4000400,0x200001,0x1100270e,0x4000400,
+0x200002,0x1100270e,0x4000400,0x500001,0x1100270e,0x7c00100,0x220401,0x1100270e,0x7c00100,0x250401,0x11002800,0x80000,0x918820,0x11002800,0x80000,0x1c18020,
+0x11002800,0x180000,0x918820,0x11002800,0x4000001,0x445801,0x11002800,0x4000001,0x445802,0x11002800,0x4000001,0xc4000b,0x11002800,0x6800000,0x201c00,0x11002800,
+0x6800020,0x201c00,0x11002800,0x24000000,0x200000,0x11002800,0x24000000,0x200002,0x11002800,0x24000000,0x810000,0x11002800,0x24000000,0x1410000,0x11002800,0x24000000,
+0x1500000,0x11002800,0x24000000,0x1500002,0x11002800,0x24000002,0x400000,0x11002800,0x24000006,0xc0000b,0x11002800,0x24000008,0x1410000,0x11002800,0x24000008,0x1710000,
+0x11002800,0x24000020,0x1001400,0x11002800,0x24000020,0x1500002,0x11002800,0x2c000010,0x1248000,0x11002800,0x2c000010,0x15248002,0x11002800,0x40000001,0x63b020,0x11002800,
+0x40080000,0x918820,0x11002801,0x80000,0xaa65620,0x11002801,0x82000,0x962460,0x11002900,0x4000000,0x20000e,0x11002900,0x4000000,0x20000f,0x11002900,0x4000020,
+0x20000e,0x11002900,0x4000020,0x20000f,0x11002900,0x4000020,0x81000e,0x11002900,0x4000020,0x81000f,0x11002900,0x4000020,0x141000e,0x11002900,0x4000020,0x141000f,
+0x11002900,0x4000022,0x20000e,0x11002900,0x4000022,0x20000f,0x11002a00,0x4000000,0x1500000,0x11002a00,0x4000000,0x1600000,0x11002a00,0x4000000,0x1600002,0x11002b01,
+0x2000,0x962460,0x11002b01,0x2802020,0x962460,0x11002c00,0x4000000,0x200000,0x11002c00,0x4000000,0x200002,0x11002c00,0x4000000,0x20000f,0x11002c00,0x4000020,
+0x200000,0x11002c00,0x7c00000,0x200000,0x11002c00,0x7c00020,0x200000,0x11002c00,0x7c00120,0x220405,0x11002c00,0x7c00120,0x230402,0x11002c00,0x7c00120,0x250402,
+0x11002c00,0x7c00120,0x250405,0x11002c19,0x7c00100,0x250400,0x11002c19,0x7c00100,0x250401,0x11002d00,0x4000000,0x100006,0x11002d00,0x4000000,0x200006,0x11002d19,
+0x7c00100,0x220402,0x11002d19,0x7c00100,0x230400,0x11002d19,0x7c00100,0x250402,0x11002e00,0x24000000,0x200000,0x11002e00,0x24000020,0x200000,0x11002e00,0x24000020,
+0x200001,0x11002e00,0x24000020,0x14200000,0x11002f00,0x24000020,0x200000,0x11002f00,0x24000020,0x200001,0x11002f00,0x24000020,0x200002,0x11002f00,0x24000020,0xf00000,
+0x11002f00,0x24000020,0x1600000,0x11002f00,0x24000022,0x1600000,0x11003000,0x24000000,0x200000,0x11003000,0x24000000,0x14200000,0x11003000,0x24000020,0x200000,0x11003000,
+0x24000020,0x810000,0x11003000,0x24000020,0x1410000,0x11003100,0x24000000,0x200000,0x11003200,0x24000000,0x200000,0x11003300,0x4000000,0x100003,0x11003400,0x24000000,
+0x100000,0x11003400,0x24000000,0x200000,0x11003500,0x24000000,0x200000,0x11003600,0x24000000,0x200000,0x11003600,0x24000000,0x14200000,0x11003600,0x24000020,0x200000,
+0x11003700,0x24000000,0x200000,0x11003700,0x24000000,0x4200000,0x11003700,0x24000000,0x4e00000,0x11003700,0x24000000,0x14200000,0x11003700,0x24000000,0x14e00000,0x11003700,
+0x24000000,0x96800000,0x11003700,0x24000020,0x4200000,0x11003800,0x4000000,0x100000,0x11003800,0x24000000,0x200000,0x11003800,0x24000000,0xb00000,0x11003800,0x24000000,
+0x1710000,0x11003800,0x24000000,0x4200000,0x11003800,0x24000000,0x4e00000,0x11003800,0x24000000,0x14200000,0x11003800,0x24000000,0x14b00000,0x11003800,0x24000000,0x14e00000,
+0x11003800,0x24000000,0x96800000,0x11005003,0x7c00100,0x220402,0x11005013,0x2802500,0x962460,0x11005013,0x4000020,0x200005,0x11005013,0x7c00100,0x2633801,0x11005013,
+0x7c00100,0x2633802,0x11005013,0x7c00100,0x2633805,0x11005019,0x7c00100,0x220402,0x11005100,0x24000000,0x810000,0x11005100,0x24000000,0x1410000,0x11005102,0x7000100,
+0x230408,0x11005102,0x7c00100,0x230404,0x11005102,0x7c00100,0x230407,0x11005102,0x7c00100,0x230408,0x11005102,0x7c00100,0x230409,0x11005201,0x2802400,0x962460,
+0x11005500,0x80000,0x1e18820,0x11005502,0x7000100,0x230408,0x11005502,0x7c00100,0x230404,0x11005502,0x7c00100,0x230407,0x11005502,0x7c00100,0x230408,0x11005502,
+0x7c00100,0x230409,0x11005667,0x1000,0,0x11020200,0x80004,0x418820,0x11020200,0x4000000,0x100006,0x11020200,0x4000000,0x10000f,0x11020200,0x4000400,
+0x100002,0x11020200,0x4000400,0x500002,0x11020200,0x6800c00,0x101000,0x11020200,0x24000000,0x100000,0x11020200,0x24000000,0x1400000,0x11020200,0x24000000,0x1500000,
+0x11020200,0x24000000,0x1600000,0x11020200,0x24000000,0x14200000,0x11020200,0x24000020,0x100000,0x11020200,0x24000020,0x1600000,0x11020219,0x7c00100,0x12040f,0x11020219,
+0x7c00100,0x220400,0x11020219,0x7c00100,0x220401,0x11020219,0x7c00100,0x250400,0x11020319,0x7c00100,0x220400,0x11020319,0x7c00100,0x220401,0x11020319,0x7c00100,
+0x220402,0x11020319,0x7c00100,0x250400,0x11020319,0x7c00100,0x250402,0x11020319,0x7d00100,0x220402,0x11020419,0x7c00100,0x220401,0x11020519,0x7c00100,0x220400,
+0x11020600,0x4000400,0x100002,0x11020600,0x4000400,0x200400,0x11020600,0x7c00500,0x130400,0x11020600,0x7c00d00,0x130400,0x11020701,0x2802400,0x962460,0x11020701,
+0x2802400,0x962461,0x11020701,0x2802400,0xc62460,0x1102080e,0x7c00100,0x220400,0x1102080e,0x7c00100,0x250400,0x11020908,0x7c00100,0x220400,0x11020908,0x7c00100,
+0x220401,0x11020908,0x7c00100,0x250400,0x11020908,0x7c00100,0x250401,0x11022800,0x24000000,0x100000,0x11022800,0x24000000,0x200000,0x11022800,0x24000000,0x200002,
+0x11022800,0x24000000,0x401000,0x11022800,0x24000000,0xf00002,0x11022800,0x24000000,0xf0ac02,0x11022800,0x24000000,0x1500000,0x11022800,0x24000002,0x100000,0x11022800,
+0x24000002,0x370000,0x11022800,0x24000002,0x470000,0x11022800,0x24000006,0x400000,0x11022800,0x24000008,0x1710000,0x11022800,0x24000008,0x1712c00,0x11022800,0x24000020,
+0x100000,0x11022800,0x24000020,0x1500000,0x11022800,0x24000020,0x1500002,0x11022900,0x4000000,0x10000e,0x11022900,0x4000000,0x10000f,0x11022919,0x7c00100,0x12040f,
+0x11022c00,0x4000000,0x100002,0x11022c00,0x4000000,0x1500002,0x11022c00,0x4000000,0x1600002,0x11022c00,0x4000000,0x1410000f,0x11022c00,0x7c00120,0x120405,0x11022c0e,
+0x7c00100,0x250401,0x11022c19,0x7c00100,0x150401,0x11022d00,0x4000000,0x100006,0x11022d00,0x4000000,0x200006,0x11022d19,0x7c00100,0x120402,0x11022d19,0x7c00100,
+0x150402,0x11022e00,0x24000000,0x200000,0x11022e00,0x24000020,0x100000,0x11022e00,0x24000020,0x14100000,0x11022f00,0x24000020,0x100000,0x11022f00,0x24000020,0x100001,
+0x11022f00,0x24000020,0x100002,0x11023000,0x24000000,0x100000,0x11023300,0x4000000,0x100002,0x11023300,0x4000000,0x100003,0x11023300,0x4000100,0x120403,0x11023300,
+0x4000100,0x150403,0x11023300,0x4000100,0x14150403,0x11023400,0x24000000,0x100000,0x11023500,0x24000000,0x100000,0x11023600,0x24000000,0x100000,0x11023600,0x24000020,
+0x100000,0x11023600,0x24000020,0x14100000,0x11023700,0x24000000,0x4100000,0x11023700,0x24000000,0x4e00000,0x11023700,0x24000000,0x14100000,0x11023700,0x24000000,0x14e00000,
+0x11023700,0x24000020,0x100000,0x11023700,0x24000020,0x4100000,0x11023700,0x24000020,0x14100000,0x11023800,0x4000000,0x100000,0x11023800,0x24000000,0x200000,0x11024e67,
+0,0,0x11025600,0x4000000,0x100000,0x11042a00,0x4000000,0x1600000,0x11045700,0x4000000,0x20000a,0x11045700,0x4000020,0x20000a,0x11045712,0x7c00100,
+0xe3040a,0x11045712,0x7c80100,0xe3040a,0x11045716,0x7c00100,0xe30c0a,0x11045716,0x7c00100,0x2530c0a,0x11063d00,0x4000001,0x445811,0x11065700,0x4000000,0x810011,
+0x11065700,0x4000000,0xe00011,0x11065700,0x4000000,0x1410011,0x11065700,0x4000000,0x1500011,0x11065700,0x4000000,0x1600011,0x11065700,0x4000006,0xe70011,0x11065700,
+0x4000008,0xe00011,0x11065700,0x4000008,0xe02c11,0x11065700,0x4000010,0x871411,0x11065700,0x4000010,0x1201411,0x11065700,0x4000010,0x1271011,0x11065700,0x4000020,
+0xe00011,0x11065700,0x4000400,0xe00011,0x11065700,0x4000420,0xe00011,0x11065700,0x6800000,0xe01c11,0x11065700,0x6800040,0xe00011,0x11065700,0xc000010,0x80ac11,
+0x11065700,0xc000010,0xb48011,0x11065719,0x7c00100,0xe20411,0x11065719,0x7c00100,0xe50411,0x11065719,0x7c00140,0xe20411,0x11065719,0x7c00140,0xe50411,0x11080100,
+0x6800000,0x201c00,0x11080100,0x68000c0,0x19329800,0x11080100,0x24000000,0x200000,0x11080100,0x24000000,0x810000,0x11080100,0x24000000,0x1410000,0x11080100,0x24000000,
+0x1500000,0x11080100,0x24000000,0x1600000,0x11080100,0x24000000,0x1b00000,0x11080100,0x24000000,0x2410000,0x11080100,0x24000000,0x18200000,0x11080100,0x24000006,0xd70000,
+0x11080100,0x24000008,0x1713c00,0x11080100,0x24000008,0x1714000,0x11080100,0x24000010,0x1001400,0x11080100,0x24000010,0x1071000,0x11080100,0x24000010,0x1071400,0x11080100,
+0x24000020,0x200000,0x11080100,0x24000020,0x400000,0x11080100,0x24000020,0x1600000,0x11080100,0x24000400,0x200000,0x11080100,0x24000420,0x200000,0x11080100,0x2c000010,
+0xb48000,0x11080100,0x2c000010,0x100ac00,0x11080100,0x44000001,0x1a45800,0x11080119,0x7c00100,0x220400,0x11080119,0x7c00100,0x250400,0x11080119,0x7c001c0,0x220400,
+0x11080119,0x7c001c0,0x250400,0x11080200,0x4000400,0x200002,0x11080200,0x24000000,0x200000,0x11080200,0x24000000,0x1500000,0x11080200,0x24000000,0x1600000,0x11080200,
+0x24000020,0x200000,0x110a1e12,0x7c00100,0x2130480,0x110a1e12,0x7c80100,0x2130480,0x110a3000,0x24000000,0x34e00000,0x110a3000,0x24100000,0x810001,0x110a3000,0x24100000,
+0x1410001,0x110a3700,0x24000000,0x34200000,0x110a3d00,0x4000000,0xe00000,0x110a3d00,0x4000000,0xe00002,0x110a3d00,0x24000000,0xe00000,0x110a3d11,0x7c00300,0xe30000,
+0x110a3d11,0x7c00900,0x1230400,0x110a3d12,0x2802400,0x962460,0x110a3e14,0x7c00100,0xe30000,0x110a3e14,0x7c00100,0xe30001,0x110a3e14,0x7c00100,0x2530000,0x110a3e14,
+0x7c00900,0x1230000,0x110a3e14,0x7c00900,0x1230001,0x110a3f16,0x7c00100,0xe30c00,0x110a3f16,0x7c00100,0xe30c01,0x110a3f16,0x7c00100,0x2530c00,0x110a3f16,0x7c00900,
+0x1230c00,0x110a3f16,0x7c00900,0x1230c01,0x110a4005,0x7c00100,0xe30400,0x110a4112,0x7c00100,0xe30402,0x110a4112,0x7c80100,0xe30402,0x110a4400,0x4000000,0xe00000,
+0x110a4412,0x4000000,0xe00002,0x110a4412,0x4000000,0xe00003,0x110a4416,0x4000000,0xe00c03,0x110a4500,0x4000000,0xe0000d,0x110a4516,0x4000000,0xe00c0d,0x110a4711,
+0x7c40300,0xe30000,0x110a4f11,0x7c00300,0xe30001,0x110a4f11,0x7c40300,0xe30000,0x110a5300,0x4000000,0x810010,0x110a5300,0x4000000,0xe00002,0x110a5300,0x4000000,
+0xe00010,0x110a5300,0x4000000,0x1410010,0x110a5300,0x4000002,0xe70010,0x110a5300,0x4000008,0x810010,0x110a5300,0x4000008,0x1410010,0x110a5300,0x6800000,0xe01c02,
+0x110a5300,0x6800000,0xe01c10,0x110a5400,0x4000000,0x81000c,0x110a5400,0x4000000,0xe0000c,0x110a5400,0x4000000,0x141000c,0x110a5400,0x4000000,0x150000c,0x110a5400,
+0x4000000,0x160000c,0x110a5400,0x4000002,0xe7000c,0x110a5400,0x4000010,0x87140c,0x110a5400,0x4000010,0xe7000c,0x110a5400,0x4000010,0x120140c,0x110a5400,0x4000010,
+0x127100c,0x110a5400,0x4000020,0xe0000c,0x110a5400,0x4000026,0xe7000c,0x110a5400,0xc000010,0x80ac0c,0x110a5400,0xc000010,0xb4800c,0x11400a0c,0xc000010,0x1049400,
+0x11400c0e,0x4000010,0xb00000,0x11400c0e,0x4000010,0x1071400,0x11400c0e,0xc000010,0xb48000,0x11400c17,0x7c00900,0x230400,0x11400f42,0xc000010,0x448000,0x11400f54,
+0xc000010,0x448000,0x11401d83,0x4000000,0x200000,0x11403dab,0x4000000,0xe00000,0x114457a0,0x4000004,0x120000a,0x114457a0,0x4000008,0x81000a,0x114457a0,0x4000008,
+0x141000a,0x114457a0,0x4000010,0x87000a,0x114457a0,0xc000010,0x84800a,0x114457a9,0x3802500,0x126246a,0x114457a9,0x7c00d00,0x2530c0a,0x114a3da0,0x24000000,0x810000,
+0x114a3da0,0x24000000,0x1410000,0x114a3da0,0x24000008,0x810000,0x114a3da0,0x24000008,0x1410000,0x114a3da0,0x24000010,0x870000,0x114a3da0,0x2c000010,0x848000,0x114a3da6,
+0x4000000,0xe00000,0x114a3da6,0x24000000,0xe00000,0x114a3da6,0x24000002,0x1200000,0x114a3da6,0x24000002,0x14e00000,0x114a3da6,0x24000008,0x810000,0x114a3da6,0x24000008,
+0x1410000,0x114a3da9,0x7c00900,0x930c00,0x114a3da9,0x7c00900,0xe30c00,0x114a3dab,0x7c00300,0xe30000,0x114a3ea9,0x7000400,0x1200c02,0x114a3fa0,0x4000004,0x1200000,
+0x114a3fa9,0x7c00d00,0x2530c00,0x114a42ab,0x4000000,0xe00000,0x114a42ab,0x4000000,0xe0000f,0x114a44ab,0x4000000,0xe00002,0x114a44ab,0x4000000,0xe00003,0x114a44ab,
+0x4000000,0x14e00003,0x114a45ab,0x4000000,0xe00002,0x114a45ab,0x4000000,0xe0000d,0x1180090a,0x2802400,0x962460,0x11800c1f,0x2802100,0x962460,0x11800c1f,0x2802500,
+0x962460,0x11800f29,0x2802400,0x962460,0x11800f36,0x2802400,0x962460,0x11820700,0x2802400,0x962460,0x11820700,0x2802500,0x962460,0x118a3dac,0x2802400,0x962460,
+0x118a3ea9,0x2802400,0x962460,0x11c00904,0x2802400,0x962460,0x11c00908,0x2802400,0x962460,0x11c00c23,0x6800000,0x1329800,0x11c00c27,0xc000010,0xb48000,0x11c00f6b,
+0x6800000,0x1329800,0x11c01070,0x6800000,0x1329800,0x11c01174,0x6800000,0x1329800,0x11c01278,0x6800000,0x1329800,0x11c0147c,0x4000000,0x200000,0x11c0147c,0x6800000,
+0x1329800,0x11c05123,0x7c00100,0x230408,0x20000067,0x1000,0,0x20000b13,0x2802400,0x962460,0x20000b13,0x2802500,0x962460,0x20001b27,0x2802100,0x962460,
+0x20001b27,0x2802100,0x962461,0x20001b27,0x2802400,0x962460,0x20001b27,0x2806400,0x962460,0x20001b27,0x2902100,0x962462,0x20001b27,0x4000000,0x200000,0x20001b27,
+0x4000000,0x400000,0x20001b27,0x4000000,0x500000,0x20001b27,0x4000000,0x810000,0x20001b27,0x4000000,0xb00000,0x20001b27,0x4000000,0xc0000b,0x20001b27,0x4000000,
+0x1410000,0x20001b27,0x4000010,0xb00000,0x20001b27,0x4000010,0xc00000,0x20001b27,0x6800000,0x1329800,0x20001b27,0x6800100,0x462540,0x20001b27,0x6800400,0x962540,
+0x20001b27,0x7c00100,0x230400,0x20001b27,0x7c00100,0x230401,0x20002619,0x7c00100,0x220401,0x20002a00,0x4000000,0x1600000,0x20004b67,0,0x1900020,0x20004c67,
+0,0x1900020,0x20004d67,0,0x1900020,0x20006d67,0x1000,0,0x20006e67,0x1000,0,0x20026d67,0,0,0x20026e67,0,
+0,0x200a4a12,0x7c00100,0x1f304c1,0x200a4a12,0x7c00100,0x20304e1,0x21005600,0x4000000,0x700000,0x21022a00,0x4000000,0x1600000,0x30000419,0x7c00100,0x220400,
+0x30000419,0x7c00100,0x220401,0x30000419,0x7c00100,0x250400,0x30000419,0x7c00100,0x250401,0x30000519,0x7c00100,0x220400,0x30000600,0x4000400,0x200400,0x30000600,
+0x7c00500,0x230400,0x30000605,0x4000400,0x200000,0x3000080e,0x7c00100,0x220400,0x30000908,0x2000,0x962460,0x30000908,0x7c00100,0x220400,0x30000908,0x7c00100,
+0x220401,0x30000908,0x7c00100,0x250400,0x30000908,0x7c00100,0x250401,0x30000a03,0x4000006,0x400000,0x30000c02,0x4000000,0x200000,0x30000c02,0x7c00100,0x230400,
+0x30000d22,0x2802100,0x962460,0x30000d22,0x2802400,0x962460,0x30000d22,0x2802500,0x962460,0x30000d22,0x4000000,0x200000,0x30000d22,0x4000010,0x200000,0x30000d22,
+0x7c00100,0x230400,0x30000d22,0xc000010,0x248000,0x30000d22,0x80000000,0x218960,0x30000e25,0x2802500,0x962460,0x30000e25,0x7c00100,0x230400,0x30001821,0x2802100,
+0x962460,0x30001821,0x2806400,0x962460,0x30001821,0x4000000,0x200000,0x30001821,0x6800100,0x962540,0x30001821,0x6800100,0x962541,0x30001821,0x7c00100,0x230400,
+0x30001b27,0x2802100,0x962460,0x30001b27,0x2802400,0x962460,0x30001b27,0x4000000,0x200000,0x30001b27,0x4000000,0x400000,0x30001b27,0x7c00100,0x230400,0x30001c1c,
+0x2802100,0x1862460,0x30001c1c,0x2802400,0x1862460,0x30001c1c,0x2806400,0x1862460,0x30001c1c,0x4000000,0x200000,0x30001c1c,0x6800100,0x1862400,0x30001c1c,0x6800100,
+0x1862540,0x30001c1c,0x7c00100,0x1830000,0x30001c1c,0x7c00100,0x1830001,0x30001c1c,0xc000010,0x448000,0x30001f0b,0x4000000,0x200000,0x30001f0b,0x4000010,0x200000,
+0x30001f0b,0x4000010,0x400000,0x30001f0b,0x6800000,0x200000,0x30001f0b,0x7c00100,0x230400,0x30001f0b,0xc000010,0x248000,0x30002006,0x7c00100,0x250400,0x30002128,
+0x4000010,0x200000,0x30002128,0x7c00100,0x230400,0x30002128,0xc000010,0x248000,0x3000221d,0x4000000,0x810000,0x3000221d,0x4000000,0x1410000,0x3000221d,0x4000001,
+0x445800,0x3000221d,0x7c00100,0x230400,0x30002300,0x4000010,0x400000,0x30002320,0x7c00100,0x230400,0x30002417,0x2802100,0x1862460,0x30002417,0x2802400,0x1862460,
+0x30002417,0x2806400,0x1862460,0x30002417,0x2882000,0x1862460,0x30002417,0x4000000,0x200000,0x30002417,0x4000000,0x400000,0x30002417,0x4000000,0x1600000,0x30002417,
+0x4000010,0x400000,0x30002417,0x4000010,0x1200000,0x30002417,0x6800000,0x1329800,0x30002417,0x6800100,0x1862540,0x30002417,0x7c00100,0x1830000,0x30002417,0x7d00100,
+0x1830000,0x3000251b,0x80000,0xc18820,0x3000251b,0x2802100,0x962460,0x3000251b,0x3c02100,0x962460,0x3000251b,0x4000000,0x200000,0x3000251b,0x4000006,0x500000,
+0x3000251b,0x4000010,0x400000,0x3000251b,0x4000010,0xb70000,0x3000251b,0x4000800,0x200000,0x3000251b,0x6800000,0x1329800,0x3000251b,0x7c00100,0x230400,0x3000251b,
+0x7c00900,0x230400,0x3000251b,0xc000010,0xb48000,0x3000251b,0x12882000,0x962460,0x30002800,0x4000001,0xc41c0b,0x30002800,0x24000000,0x200000,0x30002800,0x2c000010,
+0x1248002,0x30002800,0x2c000010,0x15248002,0x30002a00,0x4000000,0x1600000,0x30002b01,0x2000,0x962460,0x30002b01,0x2000,0x8962460,0x30002c00,0x4000000,0x200000,
+0x30002c00,0x7c00100,0x14220405,0x30002d19,0x7c00100,0x250400,0x30002e00,0x24000000,0x200000,0x30003000,0x24000000,0x200000,0x30003000,0x24000000,0x4200000,0x30003100,
+0x24000000,0x200000,0x30003600,0x24000000,0x200000,0x30003700,0x24000000,0x4200000,0x3000392e,0x24000000,0x200000,0x30005013,0x7c00100,0x2633801,0x30005600,0,
+0x918820,0x30020600,0x4000400,0x500400,0x30020701,0x2802400,0x962460,0x30020701,0x2802400,0xc62460,0x300a3a11,0x4020000,0xe00000,0x300a3a11,0x4020000,0xe00002,
+0x300a3b11,0x4020000,0xe00002,0x300a3c00,0x4008000,0xe00000,0x300a3c00,0x4010000,0xe00000,0x300a3d11,0x7c00300,0xe30002,0x300a4305,0x7c00100,0xe30400,0x300a4611,
+0x7c40300,0xe30000,0x300a4829,0x7c00100,0xe30400,0x300a4829,0x7c00900,0x1230400,0x300a4929,0x4000000,0xe00000,0x30402589,0x4000010,0x400000,0x30402589,0x4000010,
+0xb70000,0x30402589,0xc000010,0xb48000,0x304a3dab,0x4000000,0xe00000,0x30800c1f,0x2802100,0x962460,0x30c01c81,0x6800000,0x1329800,0x3100080e,0x7c00120,0x220402,
+0x3100080e,0x7c00120,0x250402,0x31005167,0x1000,0,0x3100581e,0x4000000,0x200000,0x3100581e,0x7c00100,0x230400,0x3100590d,0x7c00100,0x230400,0x31005a09,
+0x7c00100,0x220400,0x31005a09,0x7c00100,0x250400,0x31005b00,0x4000000,0x200000,0x31005c00,0x80000,0x918820,0x31005c00,0x2802000,0x962460,0x31005c00,0x2802400,
+0x962460,0x31005c00,0x4000000,0x200000,0x31005c00,0x4000000,0x200001,0x31005c00,0x6800000,0x962540,0x31005c00,0x6800400,0x962540,0x31005c01,0x2802400,0x962460,
+0x31005d00,0x4000020,0x200005,0x31005d00,0x6800020,0x1329805,0x31005d00,0x7c00120,0x220405,0x31005d00,0x7c00120,0x250405,0x31006000,0x82000,0x8962460,0x31006000,
+0x180000,0x918820,0x310a5e11,0x7c40300,0xe30000,0x310a5f11,0x7c00300,0xe30001,0x32000419,0x7c00100,0x250400,0x3200080e,0x4000020,0x200000,0x3200080e,0x7c00100,
+0x220400,0x3200080e,0x7c00100,0x250400,0x32000908,0x7c00100,0x220400,0x32000908,0x7c00100,0x250400,0x32000c02,0x7c00100,0x230400,0x32000e25,0x7c00100,0x230400,
+0x32001d0c,0x7c00100,0x220400,0x32002800,0x80000,0x1e18820,0x32002800,0x80020,0x218820,0x32002800,0x4000001,0x445802,0x32002800,0x24000000,0x200000,0x32002800,
+0x24000000,0x200002,0x32002800,0x24000020,0x200000,0x32002800,0x2c000010,0x1248002,0x32002919,0x7c00100,0x22040f,0x32002a00,0x4000000,0x1600000,0x32002b01,0x2000,
+0x962460,0x32002b01,0x2802000,0x962460,0x32002b01,0x2802020,0x962460,0x32002c00,0x4000000,0x200000,0x32002c00,0x4000020,0x200000,0x32002c00,0x4000020,0x200005,
+0x32002c00,0x7c00120,0x220405,0x32002c00,0x7c00120,0x250405,0x32002e00,0x24000020,0x200000,0x32002f00,0x24000020,0x200000,0x32003000,0x24000000,0x200000,0x32003000,
+0x24000020,0x200000,0x32003500,0x24000000,0x200000,0x32003600,0x24000020,0x200000,0x32003600,0x24000020,0x14200000,0x32003700,0x24000000,0x200000,0x32003700,0x24000000,
+0x4100000,0x32003700,0x24000000,0x4200000,0x32003700,0x24000000,0x14200000,0x32003800,0x24000000,0x810000,0x32003800,0x24000000,0x1410000,0x32005102,0x4000000,0x1500008,
+0x32005502,0x7c00100,0x230400,0x32006108,0x7c00100,0x220400,0x32006108,0x7c00100,0x250400,0x3200622a,0x2802100,0x962460,0x3200622a,0x2806000,0x962460,0x3200622a,
+0x7c00100,0x230400,0x3200632b,0x2802100,0x962460,0x3200632b,0x2806000,0x962460,0x3200632b,0x7c00100,0x230400,0x3200642c,0x2802100,0x962460,0x3200642c,0x7c00100,
+0x230400,0x3200652d,0x2802100,0x962460,0x3200652d,0x7c00100,0x230400,0x32006600,0x24000020,0x200000,0x32006700,0x24000020,0x200000,0x32006800,0x24000020,0x200000,
+0x32006800,0x24000020,0x14200000,0x32006900,0x24000020,0x200000,0x32006900,0x24000020,0x810000,0x32006900,0x24000020,0x1410000,0x32006a00,0x24000020,0x200000,0x32006a00,
+0x24000020,0x200001,0x32006a00,0x24000020,0x200002,0x32020701,0x2882000,0xc62460,0x32023300,0x4000000,0x100000,0x32026c01,0x12882000,0x962460,0x32026c01,0x12882000,
+0x8962460,0x32065700,0x4000000,0x810011,0x32065700,0x4000000,0x1410011,0x32086600,0x24000020,0x810000,0x32086600,0x24000020,0x1410000,0x32086900,0x24000020,0x810000,
+0x32086900,0x24000020,0x1410000,0x320a3600,0x24000020,0x34200000,0x320a3d11,0x7c00100,0x1230400,0x320a3e14,0x7c00100,0xe30010,0x320a3e14,0x7c00100,0x2530000,0x320a3f16,
+0x7c00100,0xe30c10,0x320a4400,0x4000000,0xe00003,0x320a4929,0x4000000,0xe00000,0x320a4f11,0x7c00300,0xe30001,0x320a6b16,0x7c00100,0x2530c00,0x32406385,0xc000010,
+0x448000,0x324a3dae,0x4000000,0x14e00000,0x324a3dae,0x7c00100,0x1230400,0x324a3fa9,0x4000002,0x1200c00,0x324a53a6,0x24000000,0xe00000,0x32820701,0x2802000,0x962460,
+0x40000419,0x7c00100,0x220400,0x40000519,0x7c00100,0x220400,0x40000600,0x4000400,0x200400,0x4000080e,0x7c00100,0x220400,0x4000080e,0x7c00100,0x250400,0x4000080e,
+0x7c00100,0x250402,0x40000c02,0x2802100,0x962460,0x40000c02,0x2802400,0x962460,0x40000c02,0x2802500,0x962460,0x40000c02,0x4000000,0x200000,0x40000c02,0x4000000,
+0x1071400,0x40000c02,0x7c00100,0x230400,0x40000c02,0x80000000,0x218960,0x40000d22,0x7c00100,0x230400,0x40000f0a,0x7c00100,0x230400,0x40001004,0x7c00100,0x230400,
+0x40001110,0x2802100,0x962460,0x40001110,0x6800100,0x962540,0x4000120f,0x2802100,0x962460,0x4000120f,0x4000000,0x1600000,0x4000120f,0x7c00100,0x230400,0x4000131f,
+0x7c00100,0x230400,0x40001423,0x4000000,0x200000,0x40001423,0x4000000,0x1600000,0x40001615,0x2802400,0x962460,0x40001615,0x7c00100,0x230400,0x40002417,0x2802400,
+0x1862460,0x40002417,0x4000000,0x200000,0x40002800,0x6800000,0x201c00,0x40002800,0x24000002,0x200000,0x40002c00,0x4000000,0x200002,0x40003000,0x24000000,0x14200000,
+0x40003000,0x24000020,0x200000,0x40003700,0x24000000,0x200000,0x40003700,0x24000000,0x4200000,0x40003700,0x24000000,0x14200000,0x40005a09,0x7c00100,0x220400,0x40005a09,
 0x7c00100,0x250400,0x40005d00,0x7c00120,0x220405,0x40006f30,0x2802100,0x962460,0x40006f30,0x2802400,0x962460,0x40006f30,0x4000000,0x200000,0x40006f30,0x6800000,
 0x1329800,0x40006f30,0x6800100,0x962540,0x40006f30,0x7c00100,0x230400,0x40006f30,0xc000010,0xb48000,0x40007034,0x7c00100,0x1830000,0x40007117,0x4000000,0x200000,
 0x40007208,0x7c00100,0x220400,0x4000720e,0x7c00100,0x220400,0x4000720e,0x7c00500,0x22040e,0x4000720e,0x7c00500,0x22040f,0x40007219,0x7c00100,0x220400,0x40007219,
-0x7c00500,0x220400,0x40007219,0x7c00500,0x22040e,0x40007219,0x7c00500,0x22040f,0x40007300,0x24000000,0x200000,0x40007300,0x24000000,0x10200000,0x40007400,0x4000000,
+0x7c00500,0x220400,0x40007219,0x7c00500,0x22040e,0x40007219,0x7c00500,0x22040f,0x40007300,0x24000000,0x200000,0x40007300,0x24000000,0x14200000,0x40007400,0x4000000,
 0x200000,0x40007531,0x7c00100,0x230400,0x40007631,0x7c00100,0x230400,0x40007835,0x4000010,0x400000,0x40007835,0x7c00100,0x230400,0x40007933,0x7c00100,0x230400,
 0x40007a32,0x6800000,0x1329800,0x40007a32,0x7c00100,0x230400,0x40007b2f,0x7c00100,0x230400,0x40007c00,0x4000000,0x200000,0x40020701,0x2802400,0x962460,0x40020701,
-0x2802400,0xc62460,0x40023300,0x4000000,0x200000,0x40027d01,0x12882000,0x962460,0x400a3700,0x24000000,0x30200000,0x400a3700,0x24000000,0x30e00000,0x400a4400,0x4000000,
+0x2802400,0xc62460,0x40023300,0x4000000,0x200000,0x40027d01,0x12882000,0x962460,0x400a3700,0x24000000,0x34200000,0x400a3700,0x24000000,0x34e00000,0x400a4400,0x4000000,
 0xe0000d,0x400a4412,0x4000000,0xe00002,0x400a4412,0x4000000,0xe00003,0x400a4500,0x4000000,0xe0000d,0x400a5300,0x4000000,0x810010,0x400a5300,0x4000000,0x1410010,
-0x404077bb,0x4000000,0x200000,0x404077be,0x4000000,0x200000,0x404077be,0x4000000,0x400000,0x40c0511d,0x4000000,0x200000,0x41000419,0x7c00100,0x220400,0x41000419,
-0x7c00100,0x250400,0x4100080e,0x7c00100,0x220400,0x4100080e,0x7c00100,0x250400,0x41000908,0x7c00100,0x220400,0x41000908,0x7c00100,0x250400,0x41000b13,0x2802000,
-0x962460,0x41000b13,0x2802100,0x962460,0x41000b13,0x4000000,0xb00000,0x41000c02,0x2802100,0x962460,0x41000c02,0x4000000,0xb00000,0x41000c02,0x4000000,0x1500000,
-0x41000f0a,0x7c00100,0x230400,0x41001004,0x7c00100,0x230400,0x41001423,0x7c00100,0x230400,0x41001b27,0x4000000,0x500000,0x41001d0c,0x7c00100,0x230400,0x41001d0c,
-0x7c00100,0x23040f,0x41001f0b,0x2802100,0x962460,0x41001f0b,0x4000000,0x200000,0x41001f0b,0x7c00100,0x230400,0x41002800,0x24000000,0x200000,0x41002800,0x24000000,
-0x400000,0x41002919,0x7c00100,0x22040e,0x41002a00,0x4000000,0x1600000,0x41002b01,0x2802020,0x962460,0x41002c00,0x4000000,0x200000,0x41002c00,0x7c00120,0x220405,
-0x41003000,0x24000000,0x200000,0x41003700,0x24000000,0x200000,0x41003700,0x24000000,0x10200000,0x41003700,0x24000000,0x10205200,0x41003700,0x24000000,0x10e00000,0x41005d00,
+0x404077e0,0x4000000,0x200000,0x404077e3,0x4000000,0x200000,0x404077e3,0x4000000,0x400000,0x40c0147c,0x4000000,0x200000,0x40c05123,0x4000000,0x200000,0x41000419,
+0x7c00100,0x220400,0x41000419,0x7c00100,0x250400,0x4100080e,0x7c00100,0x220400,0x4100080e,0x7c00100,0x250400,0x41000908,0x7c00100,0x220400,0x41000908,0x7c00100,
+0x250400,0x41000b13,0x2802000,0x962460,0x41000b13,0x2802100,0x962460,0x41000b13,0x4000000,0xb00000,0x41000c02,0x2802100,0x962460,0x41000c02,0x4000000,0x1500000,
+0x41000c02,0xc000010,0xb48000,0x41000f0a,0x7c00100,0x230400,0x41001004,0x7c00100,0x230400,0x41001423,0x7c00100,0x230400,0x41001b27,0x4000000,0x500000,0x41001d0c,
+0x7c00100,0x220400,0x41001d0c,0x7c00100,0x23040f,0x41001f0b,0x2802100,0x962460,0x41001f0b,0x4000000,0x200000,0x41001f0b,0x7c00100,0x230400,0x41002800,0x24000000,
+0x200000,0x41002800,0x24000000,0x400000,0x41002919,0x7c00100,0x22040e,0x41002a00,0x4000000,0x1600000,0x41002b01,0x2802020,0x962460,0x41002c00,0x4000000,0x200000,
+0x41002c00,0x7c00120,0x220405,0x41003000,0x24000000,0x200000,0x41003700,0x24000000,0x4200000,0x41003700,0x24000000,0x14200000,0x41003700,0x24000000,0x14e00000,0x41005d00,
 0x7c00120,0x220405,0x41006600,0x24000020,0x200000,0x41006600,0x24000020,0x810000,0x41006600,0x24000020,0x1410000,0x41007208,0x7c00100,0x22040f,0x41007219,0x7c00100,
 0x220400,0x41007300,0x24000000,0x200000,0x41007e0e,0x2802000,0x962460,0x41007e0e,0x4000000,0x200000,0x41007f0e,0x4000000,0x200000,0x41007f0e,0x7c00100,0x230400,
 0x41008002,0x7c00100,0x230400,0x41008137,0x2802100,0x962460,0x41008137,0x4000000,0x200000,0x41008137,0x6800100,0x962540,0x41008137,0x7c00100,0x230400,0x41008301,
@@ -3431,20 +3501,20 @@ static const uint32_t propsVectors[6375]={
 0x41008d19,0x7c00100,0x220400,0x41008d19,0x7c00100,0x22040f,0x41008e00,0x24000000,0x200000,0x41008e00,0x24000000,0x400000,0x41008e00,0x24000000,0x1710000,0x41008e00,
 0x24000006,0x400000,0x41008f3a,0x2802000,0x962460,0x41008f3a,0x2802100,0x962460,0x41008f3a,0x2806000,0x962460,0x41008f3a,0x4000000,0x200000,0x41008f3a,0x6800100,
 0x962540,0x41008f3a,0x7c00100,0x230400,0x4100903c,0x7c00100,0x230400,0x4100903c,0x7c00100,0x23040f,0x41020701,0x2802000,0x962460,0x41020701,0x2802000,0xc62460,
-0x410a3700,0x24000000,0x30200000,0x410a3700,0x24000000,0x30e00000,0x410a4412,0x4000000,0xe00003,0x410a4711,0x7c40300,0xe30000,0x410a4f11,0x7c00300,0xe30001,0x410a9100,
+0x410a3700,0x24000000,0x34200000,0x410a3700,0x24000000,0x34e00000,0x410a4412,0x4000000,0xe00003,0x410a4711,0x7c40300,0xe30000,0x410a4f11,0x7c00300,0xe30001,0x410a9100,
 0x4000000,0x800010,0x410a9100,0x4000000,0x810010,0x410a9100,0x4000000,0x870010,0x410a9100,0x4000000,0xb00010,0x410a9100,0x4000000,0xf00010,0x410a9100,0x4000000,
-0x1001410,0x410a9100,0x4000000,0x1071010,0x410a9100,0x4000000,0x1071410,0x410a9100,0x4000000,0x1410010,0x414a8295,0x4000000,0xe00000,0x41808300,0x2802000,0x962460,
-0x41c0146b,0x6800000,0x1329800,0x50000419,0x7c00100,0x220400,0x50000419,0x7c00100,0x250400,0x5000080e,0x7c00100,0x220400,0x50000908,0x7c00100,0x220400,0x50000908,
+0x1001410,0x410a9100,0x4000000,0x1071010,0x410a9100,0x4000000,0x1071410,0x410a9100,0x4000000,0x1410010,0x414a82ab,0x4000000,0xe00000,0x41808300,0x2802000,0x962460,
+0x41c0147c,0x6800000,0x1329800,0x50000419,0x7c00100,0x220400,0x50000419,0x7c00100,0x250400,0x5000080e,0x7c00100,0x220400,0x50000908,0x7c00100,0x220400,0x50000908,
 0x7c00100,0x250400,0x50000b13,0x2802500,0x962460,0x50000f0a,0x7c00100,0x230400,0x50001615,0x2802100,0x962460,0x50001615,0x7c00100,0x230400,0x50002b01,0x2802020,
 0x962460,0x50002c00,0x4000000,0x200000,0x50002c19,0x7c00100,0x220400,0x50002d19,0x7c00100,0x220400,0x50003000,0x24000000,0x200000,0x50003000,0x24000020,0x200000,
-0x50003700,0x24000000,0x200000,0x50005d00,0x7c00120,0x220405,0x50005d00,0x7c00120,0x250405,0x50006108,0x7c00100,0x220400,0x50006108,0x7c00100,0x250400,0x50006600,
+0x50003700,0x24000000,0x4200000,0x50005d00,0x7c00120,0x220405,0x50005d00,0x7c00120,0x250405,0x50006108,0x7c00100,0x220400,0x50006108,0x7c00100,0x250400,0x50006600,
 0x24000020,0x200000,0x50007300,0x24000000,0x200000,0x50008301,0x2802400,0x962460,0x50008a00,0x7c00500,0x230400,0x50009257,0x2802400,0x962460,0x50009257,0x4000000,
 0x200000,0x50009257,0x4000010,0x1071400,0x50009257,0x6800000,0x1329800,0x50009257,0x7c00100,0x230400,0x50009257,0x7c00500,0x230400,0x50009257,0x7c00900,0x230400,
 0x50009257,0xc000010,0xb48000,0x5000933e,0x2802100,0x962460,0x5000933e,0x2802400,0x962460,0x5000933e,0x4000000,0x200000,0x5000933e,0x4000000,0x400000,0x5000933e,
 0x4000010,0x400000,0x5000933e,0x6800000,0x1329800,0x5000933e,0x6800100,0x962540,0x5000933e,0x6800100,0x962541,0x5000933e,0x6804400,0x962540,0x5000933e,0x7c00100,
 0x230400,0x5000933e,0x7c00100,0x230401,0x5000933e,0xc000010,0x448000,0x50009419,0x7c00100,0x220400,0x50009419,0x7c00100,0x250400,0x50009500,0x4000400,0x200400,
 0x5000965a,0x4000000,0x500000,0x5000965a,0x7c00100,0x230400,0x5000965a,0xc000010,0xb48000,0x5000975b,0x4000000,0x200000,0x5000975b,0x4000010,0x400000,0x5000975b,
-0x7c00100,0x230400,0x50009865,0x7c00100,0x230400,0x50009965,0x4000010,0x400000,0x50009965,0x7c00100,0x230400,0x50409a95,0x4000000,0x200000,0x5100080e,0x7c00100,
+0x7c00100,0x230400,0x50009865,0x7c00100,0x230400,0x50009965,0x4000010,0x400000,0x50009965,0x7c00100,0x230400,0x50409aab,0x4000000,0x200000,0x5100080e,0x7c00100,
 0x220400,0x5100080e,0x7c00100,0x250400,0x51000c02,0x2802100,0x962460,0x51000c02,0x4000000,0x1500000,0x51000c02,0x4000020,0x200000,0x51000c02,0x7c00100,0x230400,
 0x51000f0a,0x7c00100,0x230400,0x51000f0a,0x7c00500,0x230400,0x51001110,0x2802100,0x962460,0x5100131f,0x2802100,0x962460,0x51001423,0x7c00100,0x230400,0x51001524,
 0x2802100,0x962460,0x51001524,0x4000000,0x200000,0x51001524,0x7c00100,0x230400,0x5100171a,0x2802100,0x962460,0x5100171a,0x4000000,0x200000,0x5100171a,0x4000000,
@@ -3452,7 +3522,7 @@ static const uint32_t propsVectors[6375]={
 0x51001c1c,0x2802100,0x1862460,0x51001c1c,0x2802400,0x1862460,0x51001c1c,0x2806400,0x1862460,0x51001c1c,0x4000000,0x1800000,0x51001c1c,0x6800000,0x1329800,0x51001c1c,
 0x6800000,0x1862400,0x51001c1c,0x6800100,0x1862400,0x51001c1c,0x6800100,0x1862540,0x51001c1c,0x6800400,0x1862400,0x51001c1c,0x7c00100,0x1830000,0x5100251b,0x7c00100,
 0x230400,0x51002619,0x7c00100,0x220400,0x51002619,0x7c00100,0x250400,0x51002800,0x80020,0x218820,0x51002c00,0x4000000,0x200000,0x51002d19,0x7c00100,0x230400,
-0x51003700,0x24000000,0x200000,0x51003700,0x24000000,0xe00000,0x51005201,0x2802400,0x962460,0x51005c00,0x4000000,0x200000,0x51006108,0x7c00100,0x220400,0x51006108,
+0x51003700,0x24000000,0x4200000,0x51003700,0x24000000,0x4e00000,0x51005201,0x2802400,0x962460,0x51005c00,0x4000000,0x200000,0x51006108,0x7c00100,0x220400,0x51006108,
 0x7c00100,0x250400,0x51006600,0x24000020,0x200000,0x51006600,0x24000020,0x810000,0x51006600,0x24000020,0x1410000,0x51007300,0x24000000,0x200000,0x51007300,0x24000020,
 0x200000,0x51008002,0x7c00100,0x230400,0x51008301,0x2802000,0x962460,0x51008301,0x2802400,0x962460,0x51008a00,0x7c00500,0x230400,0x51008e00,0x24000000,0x200000,
 0x51008e00,0x24000000,0x400000,0x51008e00,0x24000000,0x810000,0x51008e00,0x24000000,0x1400000,0x51008e00,0x24000000,0x1410000,0x51008e00,0x24000000,0x1710000,0x51008e00,
@@ -3469,78 +3539,78 @@ static const uint32_t propsVectors[6375]={
 0x230400,0x5100a24f,0xc000010,0x448000,0x5100a36e,0x2802100,0x962460,0x5100a36e,0x4000000,0x200000,0x5100a36e,0x6800100,0x962540,0x5100a36e,0x6804400,0x962540,
 0x5100a36e,0x7c00100,0x230400,0x5100a442,0x2802100,0x962460,0x5100a442,0x4000000,0x200000,0x5100a442,0x6800000,0x1329800,0x5100a442,0x6800100,0x962540,0x5100a442,
 0x7c00100,0x230400,0x5100a442,0xc000010,0x448000,0x5100a500,0x4000000,0x200000,0x5100a600,0x4000000,0x200000,0x5100a601,0x2802000,0x962460,0x5100a76b,0x7c00100,
-0x230400,0x5100a868,0x7c00100,0x230400,0x5100a96c,0x4000000,0x200000,0x5100a96c,0x7c00100,0x230400,0x5100aa00,0x4000000,0xe00000,0x5100ab00,0x4000000,0xe00000,
-0x51086600,0x24000020,0x810000,0x51086600,0x24000020,0x1410000,0x510a4005,0x7c00100,0xe30400,0x510a4711,0x7c40300,0xe30000,0x510a7300,0x24000000,0x30200000,0x510aaa00,
-0x4000000,0x30e00000,0x5140a2b6,0x4000400,0x400000,0x514a8295,0x4000000,0xe00000,0x51802b87,0x2802000,0x962460,0x51c00908,0x2802400,0x962460,0x51c0a008,0x2802400,
+0x230400,0x5100a868,0x7c00100,0x230400,0x5100a96c,0x4000000,0x200000,0x5100a96c,0x7c00100,0x230400,0x5100aa00,0x4000000,0x4e00000,0x5100ab00,0x4000000,0x4e00000,
+0x51086600,0x24000020,0x810000,0x51086600,0x24000020,0x1410000,0x510a4005,0x7c00100,0xe30400,0x510a4711,0x7c40300,0xe30000,0x510a7300,0x24000000,0x34200000,0x510aaa00,
+0x4000000,0x34e00000,0x5140a2db,0x4000400,0x400000,0x514a82ab,0x4000000,0xe00000,0x51802b9d,0x2802000,0x962460,0x51c00908,0x2802400,0x962460,0x51c0a008,0x2802400,
 0x962460,0x52000f0a,0x2802100,0x962460,0x52000f0a,0x6800100,0x962540,0x52000f0a,0x7c00100,0x230400,0x52001004,0x4000000,0x1600000,0x52001b00,0x4000000,0x200000,
 0x52001c1c,0x2802100,0x1862460,0x52001c1c,0x6800100,0x1862400,0x52001c1c,0x6800400,0x1862400,0x52001e12,0x7c00100,0x2230500,0x52001e12,0x7c00100,0x2330520,0x52002128,
 0x4000002,0x400000,0x52002128,0x7c00100,0x230400,0x52002a00,0x4000000,0x1500000,0x52002a00,0x4000000,0x1600000,0x52002d00,0x4000000,0x200006,0x52003000,0x24000000,
 0x200000,0x52006108,0x7c00100,0x220400,0x52006108,0x7c00100,0x250400,0x52008301,0x2802400,0x962460,0x52008407,0x2802400,0x962460,0x52008407,0x7c00100,0x220400,
 0x52008407,0x7c00100,0x250400,0x52008b3b,0x6800000,0x1800000,0x52008b3b,0x7c00100,0x1830000,0x52008e00,0x24000000,0x400000,0x52009419,0x7c00100,0x250400,0x5200975b,
 0x4000000,0x200000,0x5200ac7e,0x2802000,0x962460,0x5200ac7e,0x2802100,0x962460,0x5200ac7e,0x2802400,0x962460,0x5200ac7e,0x4000010,0x200000,0x5200ac7e,0x7c00100,
-0x230400,0x5200ad28,0x7c00100,0x230400,0x5200ae6a,0x2802100,0x1862460,0x5200ae6a,0x2802400,0x962460,0x5200ae6a,0x2802400,0x1862460,0x5200ae6a,0x2806000,0x1862460,
-0x5200ae6a,0x4000000,0x1800000,0x5200ae6a,0x6800000,0x1329800,0x5200ae6a,0x6800100,0x1862400,0x5200ae6a,0x6800100,0x1862540,0x5200ae6a,0x7c00100,0x1830000,0x5200ae6a,
-0x7c00900,0x1830000,0x5200ae6a,0xc000010,0x1848000,0x5200b083,0x4000010,0x400000,0x5200b083,0x7c00100,0x230400,0x5200b083,0xc000010,0x448000,0x5200b182,0x2802400,
-0x962460,0x5200b182,0x4000000,0x200000,0x5200b182,0x4000010,0x400000,0x5200b182,0x7c00100,0x230400,0x5200b182,0xc000010,0x448000,0x5200b30a,0x2802400,0x962460,
-0x5200b30a,0x4000000,0x200000,0x5200b30a,0x7c00100,0x230400,0x5200b54e,0x2802100,0x962460,0x5200b54e,0x2802400,0x962460,0x5200b54e,0x4000000,0x200000,0x5200b54e,
-0x4000010,0x400000,0x5200b54e,0x6800000,0x1329800,0x5200b54e,0x6800100,0x962540,0x5200b54e,0x6804400,0x962540,0x5200b54e,0x7c00100,0x230400,0x5200b54e,0xc000010,
-0x448000,0x5200b61c,0x4000000,0x1800000,0x5200b61c,0x6800400,0x1862400,0x5200b61c,0x7c00100,0x1830000,0x5200b61c,0x7c00900,0x1830000,0x5200b77f,0x2802100,0x1862460,
-0x5200b77f,0x2802400,0x1862460,0x5200b77f,0x4000000,0x1800000,0x5200b77f,0x4000010,0x1800000,0x5200b77f,0x7c00100,0x1830000,0x5200b77f,0x7c00500,0x1830000,0x5200b77f,
-0x7c00900,0x1830000,0x5200b77f,0x7e00100,0x1830000,0x5200b873,0x2802100,0x962460,0x5200b873,0x2806400,0x962460,0x5200b873,0x6800000,0x1329800,0x5200b873,0x6800100,
-0x962540,0x5200b873,0x6800400,0x962540,0x5200b873,0x7c00100,0x230400,0x5200b873,0xc000010,0x448000,0x5200b912,0x7c00100,0x2230500,0x5200b912,0x7c00100,0x2330520,
-0x5200ba74,0x4000000,0x200000,0x5200ba74,0x4000010,0x400000,0x5200ba74,0x7c00100,0x230400,0x5200bb85,0x4000000,0x200000,0x5200bb85,0x7c00100,0x230400,0x5200bc75,
-0x4000000,0x400000,0x5200bc75,0x4000010,0x400000,0x5200bc75,0x7c00100,0x230400,0x5200bd7d,0x4000000,0x200000,0x5200bd7d,0x7c00100,0x230400,0x5200be7a,0x4000000,
-0x200000,0x5200be7a,0x7c00100,0x230400,0x5200bf58,0x7c00100,0x230400,0x5200c002,0x4000000,0x200000,0x5200c178,0x2802000,0x962460,0x5200c178,0x2802100,0x962460,
-0x5200c178,0x2802400,0x962460,0x5200c178,0x2806400,0x962460,0x5200c178,0x4000000,0x200000,0x5200c178,0x6800100,0x962540,0x5200c178,0x7c00100,0x230400,0x5200c178,
-0x7c00100,0x230401,0x5200c178,0xc000010,0x448000,0x5200c178,0x80000000,0x218960,0x5200c247,0x7c00100,0x230400,0x5200c247,0x7c00100,0x830400,0x5200c247,0x7c00100,
-0x1430400,0x5200c300,0x4000000,0x200003,0x52022d00,0x4000000,0x100006,0x52023700,0x24000000,0x100000,0x52023700,0x24000000,0xe00000,0x52023700,0x24000000,0x10100000,
-0x52023700,0x24000000,0x10e00000,0x52023700,0x24000000,0x928045a0,0x52024400,0x4000000,0x100000,0x52027300,0x24000000,0x100000,0x5202c300,0x4000000,0x100000,0x5202c300,
-0x4000000,0x100002,0x5202c300,0x4000000,0x100003,0x5202c300,0x4000000,0x10000d,0x5202c300,0x4000100,0x150400,0x5202c300,0x4000100,0x15040d,0x5202c300,0x4000100,
-0x10150400,0x520a1e12,0x7c00100,0x2130480,0x520a3700,0x24000000,0x30e00000,0x520a3800,0x24000000,0x30100000,0x520a4711,0x7c40300,0xe30000,0x520a4f11,0x7c00300,0xe30001,
-0x520a7300,0x24000000,0x30100000,0x520ab412,0x7c00100,0x2130480,0x520ac400,0x4000000,0xe00002,0x520ac400,0x4000000,0xe0000d,0x520ac400,0x4000000,0x30e0000d,0x520ac414,
-0x4000000,0xe0000d,0x520ac511,0x7c40300,0xe30000,0x5240af7a,0x6800400,0x962540,0x5240af7a,0x7c00100,0x230400,0x5240af7b,0x4000400,0x200000,0x5240af7b,0x6800100,
-0x962540,0x5240b29b,0x4000000,0x200000,0x5240b2a5,0x4000000,0x200000,0x5240b2a5,0x4000000,0x1500000,0x5240b5b9,0x7c00900,0x230400,0x524a4495,0x4000000,0xe00003,
-0x5280af7a,0x2802400,0x962460,0x5280af7b,0x2802400,0x962460,0x5280af7d,0x2802400,0x962460,0x5280af7f,0x2802400,0x962460,0x52c0b3b0,0x2802400,0x962460,0x52c0b3b4,
-0x7c00100,0x230400,0x60000c02,0x2802100,0x962460,0x60000c02,0x7c00100,0x230400,0x60000f0a,0x2802100,0x962460,0x60000f0a,0x6800100,0x962540,0x60000f0a,0x7c00100,
-0x230400,0x6000131f,0x4000000,0x200000,0x6000171a,0x7c00100,0x230400,0x6000171a,0x7c00100,0x230560,0x60001b27,0x2802100,0x962460,0x60001b27,0x4000000,0xc00000,
-0x60001b27,0x7c00100,0x230400,0x60001f0b,0x2802000,0x962460,0x60002919,0x7c00100,0x22040e,0x60002a00,0x4000000,0x1600000,0x60003000,0x24000000,0x10200000,0x60003000,
-0x24000000,0x10e00000,0x60003700,0x24000000,0x200000,0x60003800,0x24000000,0x1710000,0x60005102,0x4000000,0x200000,0x60006108,0x7c00100,0x220400,0x60006108,0x7c00100,
-0x250400,0x60006600,0x24000020,0x200000,0x60008301,0x2802000,0x962460,0x6000903c,0x2806000,0x962460,0x6000903c,0x4000000,0x400000,0x60009519,0x7c00100,0x220400,
-0x60009519,0x7c00100,0x250400,0x6000a008,0x7c00100,0x220400,0x6000a008,0x7c00100,0x250400,0x6000c300,0x4000000,0x3a703580,0x6000c654,0x2802000,0x962460,0x6000c654,
-0x4000010,0x200000,0x6000c654,0x7c00100,0x230400,0x6000c73f,0x2802000,0x962460,0x6000c73f,0x2802100,0x962460,0x6000c73f,0x4000000,0x200000,0x6000c73f,0x6800100,
-0x962540,0x6000c73f,0x6804000,0x962540,0x6000c73f,0x7c00100,0x230400,0x6000c80b,0x7c00100,0x230400,0x6000c941,0x2802100,0x962460,0x6000c941,0x2806000,0x962460,
-0x6000c941,0x4000000,0x200000,0x6000c941,0x4000010,0x200000,0x6000c941,0x6800000,0x1329800,0x6000c941,0x6800100,0x962540,0x6000c941,0x7c00100,0x230400,0x6000c941,
-0xc000010,0x448000,0x6000ca82,0x7c00100,0x230400,0x6000cc00,0x4000000,0xe00000,0x6000d000,0x4000000,0x200000,0x6002c300,0x4000000,0x100000,0x6002c300,0x4000000,
-0x10000d,0x6002c300,0x4000100,0x150400,0x6002c300,0x4000100,0x15040d,0x6002c300,0x4000100,0x10150400,0x600a3000,0x24000000,0x30200000,0x600a3000,0x24000000,0x30e00000,
-0x600a3700,0x24000000,0x30200000,0x600a3800,0x24000000,0x30200000,0x600a3800,0x24000000,0xb28045a0,0x600a4305,0x7c00100,0xe30400,0x600ac300,0x4000000,0x30100000,0x600ac400,
-0x4000000,0x10e0000d,0x600ac400,0x4000000,0x30e0000d,0x600acb14,0x7c00100,0xe30000,0x600acb16,0x7c00100,0xe30c00,0x600acc00,0x4000000,0x30e00000,0x600acd00,0x4000000,
-0x30200000,0x600acd00,0x4000000,0x30e00000,0x600acd00,0x4000000,0x30e05200,0x600acd00,0x4000000,0xb28045a0,0x600acd00,0x4000000,0xb28049c0,0x600ace00,0x4000000,0x30e00000,
-0x600ace00,0x4000000,0xb28045a0,0x600acf00,0x4000000,0x30e00000,0x600acf00,0x4000000,0x30e05200,0x600acf00,0x4000000,0xb28045a0,0x600ad111,0x7c40300,0xe30000,0x604ac495,
-0x4000000,0x30e00003,0x61000a03,0x4000000,0x1600000,0x61000c02,0x80000000,0x218960,0x6100120f,0x4000000,0x200000,0x61001a18,0x7c00100,0x1830000,0x61001d0c,0x7c00100,
-0x230400,0x61001d0c,0x7c00100,0x250400,0x61006600,0x24000020,0x200000,0x61008407,0x7c00100,0x220400,0x61008407,0x7c00100,0x250400,0x6100870c,0x7c00100,0x220400,
-0x61008e00,0x24000000,0x200000,0x61008e00,0x24000000,0x400000,0x61008e00,0x24000002,0x300000,0x6100903c,0x7c00100,0x230400,0x61009519,0x7c00100,0x220400,0x61009519,
-0x7c00100,0x250400,0x61009519,0x7c00500,0x22040f,0x61009b71,0x2802100,0x962460,0x61009b71,0x2806400,0x962460,0x61009b71,0x7c00100,0x230400,0x6100a008,0x2802100,
-0x962460,0x6100c300,0x4000000,0x20000f,0x6100cd00,0x4000000,0x200000,0x6100d202,0x2802400,0x962460,0x6100d202,0x2802500,0x962460,0x6100d202,0x7c00100,0x230400,
-0x6100d302,0x4000020,0x200000,0x6100d302,0x7c00120,0x230405,0x6100d476,0x2802100,0x962460,0x6100d476,0x2802100,0x962461,0x6100d476,0x2806400,0x962460,0x6100d476,
-0x4000000,0x400000,0x6100d476,0x6800000,0x1329800,0x6100d476,0x6800100,0x962540,0x6100d476,0x7c00100,0x230400,0x6100d476,0xc000010,0x448000,0x6100d573,0x2802100,
-0x962460,0x6100d573,0x2806400,0x962460,0x6100d573,0x6800100,0x962540,0x6100d573,0x7c00100,0x230400,0x6100d573,0x7c00900,0x230400,0x6100d573,0xc000010,0x448000,
-0x6100d68d,0x7c00100,0x230400,0x6100d756,0x7c00100,0x230400,0x6100d85c,0x2802400,0x962460,0x6100d85c,0x6800100,0x962540,0x6100d85c,0x7c00100,0x230400,0x6100d85c,
-0x7c00500,0x230400,0x6100d997,0x2802100,0x962460,0x6100d997,0x4000000,0x200000,0x6100d997,0x4000000,0x400000,0x6100d997,0x6800000,0x1329800,0x6100d997,0x6800100,
-0x962540,0x6100d997,0x6804400,0x962540,0x6100d997,0x7c00100,0x230400,0x6100d997,0x7c00100,0x230560,0x6100d997,0xc000010,0x448000,0x6100da98,0x6800000,0x1329800,
-0x6100da98,0x7c00100,0x230400,0x6100db71,0x4000000,0x200000,0x6100dc99,0x2802100,0x962460,0x6100dc99,0x2802400,0x962460,0x6100dc99,0x6800000,0x1329800,0x6100dc99,
-0x6800100,0x962540,0x6100dc99,0x6804400,0x962540,0x6100dc99,0x7c00100,0x230400,0x610a4711,0x7c40300,0xe30000,0x610a4f11,0x7c00300,0xe30001,0x610ace00,0x4000000,
-0x30e00000,0x6140af7a,0x7c00100,0x230400,0x6140af7b,0x6800100,0x962540,0x6140af84,0x7c00100,0x230400,0x6180af7b,0x2802400,0x962460,0x62002a00,0x4000000,0x1600000,
-0x63002800,0x80000,0x918820,0x63c00c11,0x80000,0x918820,0x7000080e,0x7c00100,0x250400,0x70000a03,0x4000000,0x200000,0x70000c00,0x80000000,0x218960,0x70000f0a,
+0x230400,0x5200ac7e,0xc000010,0x248000,0x5200ad28,0x7c00100,0x230400,0x5200ae6a,0x2802100,0x1862460,0x5200ae6a,0x2802400,0x962460,0x5200ae6a,0x2802400,0x1862460,
+0x5200ae6a,0x2806000,0x1862460,0x5200ae6a,0x4000000,0x1800000,0x5200ae6a,0x6800000,0x1329800,0x5200ae6a,0x6800100,0x1862400,0x5200ae6a,0x6800100,0x1862540,0x5200ae6a,
+0x7c00100,0x1830000,0x5200ae6a,0x7c00900,0x1830000,0x5200ae6a,0xc000010,0x1848000,0x5200b083,0x4000010,0x400000,0x5200b083,0x7c00100,0x230400,0x5200b083,0xc000010,
+0x448000,0x5200b182,0x2802400,0x962460,0x5200b182,0x4000000,0x200000,0x5200b182,0x4000010,0x400000,0x5200b182,0x7c00100,0x230400,0x5200b182,0xc000010,0x448000,
+0x5200b30a,0x2802400,0x962460,0x5200b30a,0x4000000,0x200000,0x5200b30a,0x7c00100,0x230400,0x5200b54e,0x2802100,0x962460,0x5200b54e,0x2802400,0x962460,0x5200b54e,
+0x4000000,0x200000,0x5200b54e,0x4000010,0x400000,0x5200b54e,0x6800000,0x1329800,0x5200b54e,0x6800100,0x962540,0x5200b54e,0x6804400,0x962540,0x5200b54e,0x7c00100,
+0x230400,0x5200b54e,0xc000010,0x448000,0x5200b61c,0x4000000,0x1800000,0x5200b61c,0x6800400,0x1862400,0x5200b61c,0x7c00100,0x1830000,0x5200b61c,0x7c00900,0x1830000,
+0x5200b77f,0x2802100,0x1862460,0x5200b77f,0x2802400,0x1862460,0x5200b77f,0x4000000,0x1800000,0x5200b77f,0x4000010,0x1800000,0x5200b77f,0x7c00100,0x1830000,0x5200b77f,
+0x7c00500,0x1830000,0x5200b77f,0x7c00900,0x1830000,0x5200b77f,0x7e00100,0x1830000,0x5200b873,0x2802100,0x962460,0x5200b873,0x2806400,0x962460,0x5200b873,0x6800000,
+0x1329800,0x5200b873,0x6800100,0x962540,0x5200b873,0x6800400,0x962540,0x5200b873,0x7c00100,0x230400,0x5200b873,0xc000010,0x448000,0x5200b912,0x7c00100,0x2230500,
+0x5200b912,0x7c00100,0x2330520,0x5200ba74,0x4000000,0x200000,0x5200ba74,0x4000010,0x400000,0x5200ba74,0x7c00100,0x230400,0x5200bb85,0x4000000,0x200000,0x5200bb85,
+0x7c00100,0x230400,0x5200bc75,0x4000000,0x400000,0x5200bc75,0x4000010,0x400000,0x5200bc75,0x7c00100,0x230400,0x5200bd7d,0x4000000,0x200000,0x5200bd7d,0x7c00100,
+0x230400,0x5200be7a,0x4000000,0x200000,0x5200be7a,0x7c00100,0x230400,0x5200bf58,0x7c00100,0x230400,0x5200c002,0x4000000,0x200000,0x5200c178,0x2802000,0x962460,
+0x5200c178,0x2802100,0x962460,0x5200c178,0x2802400,0x962460,0x5200c178,0x2806400,0x962460,0x5200c178,0x4000000,0x200000,0x5200c178,0x6800100,0x962540,0x5200c178,
+0x7c00100,0x230400,0x5200c178,0x7c00100,0x230401,0x5200c178,0xc000010,0x448000,0x5200c178,0x80000000,0x218960,0x5200c247,0x7c00100,0x230400,0x5200c247,0x7c00100,
+0x830400,0x5200c247,0x7c00100,0x1430400,0x5200c300,0x4000000,0x200003,0x52022d00,0x4000000,0x100006,0x52023700,0x24000000,0x4100000,0x52023700,0x24000000,0x4e00000,
+0x52023700,0x24000000,0x14100000,0x52023700,0x24000000,0x14e00000,0x52023700,0x24000000,0x96800000,0x52024400,0x4000000,0x100000,0x52027300,0x24000000,0x100000,0x5202c300,
+0x4000000,0x100000,0x5202c300,0x4000000,0x100002,0x5202c300,0x4000000,0x100003,0x5202c300,0x4000000,0x10000d,0x5202c300,0x4000100,0x150400,0x5202c300,0x4000100,
+0x15040d,0x5202c300,0x4000100,0x14150400,0x520a1e12,0x7c00100,0x2130480,0x520a3700,0x24000000,0x34e00000,0x520a3800,0x24000000,0x34100000,0x520a4711,0x7c40300,0xe30000,
+0x520a4f11,0x7c00300,0xe30001,0x520a7300,0x24000000,0x34100000,0x520ab412,0x7c00100,0x2130480,0x520ac400,0x4000000,0xe00002,0x520ac400,0x4000000,0xe0000d,0x520ac400,
+0x4000000,0x34e0000d,0x520ac414,0x4000000,0xe0000d,0x520ac511,0x7c40300,0xe30000,0x5240af8b,0x7c00100,0x230400,0x5240af90,0x4000400,0x200000,0x5240af90,0x6800100,
+0x962540,0x5240af92,0x6800400,0x962540,0x5240af92,0x7c00100,0x230400,0x5240b2b1,0x4000000,0x200000,0x5240b2b1,0x4000000,0x1500000,0x5240b2bc,0x4000000,0x200000,
+0x5240b2c9,0x4000000,0x200000,0x5240b5de,0x7c00900,0x230400,0x524a44ab,0x4000000,0xe00003,0x5280af8b,0x2802400,0x962460,0x5280af8c,0x2802400,0x962460,0x5280af92,
+0x2802400,0x962460,0x5280af94,0x2802400,0x962460,0x5280af96,0x2802400,0x962460,0x52c0b3d5,0x2802400,0x962460,0x52c0b3d9,0x7c00100,0x230400,0x60000c02,0x2802100,
+0x962460,0x60000c02,0x7c00100,0x230400,0x60000f0a,0x2802100,0x962460,0x60000f0a,0x6800100,0x962540,0x60000f0a,0x7c00100,0x230400,0x6000131f,0x4000000,0x200000,
+0x6000171a,0x7c00100,0x230400,0x6000171a,0x7c00100,0x230560,0x60001b27,0x2802100,0x962460,0x60001b27,0x4000000,0xc00000,0x60001b27,0x7c00100,0x230400,0x60001f0b,
+0x2802000,0x962460,0x60002919,0x7c00100,0x22040e,0x60002a00,0x4000000,0x1600000,0x60003000,0x24000000,0x14200000,0x60003000,0x24000000,0x14e00000,0x60003700,0x24000000,
+0x4200000,0x60003800,0x24000000,0x1710000,0x60005102,0x4000000,0x200000,0x60006108,0x7c00100,0x220400,0x60006108,0x7c00100,0x250400,0x60006600,0x24000020,0x200000,
+0x60008301,0x2802000,0x962460,0x6000903c,0x2806000,0x962460,0x6000903c,0x4000000,0x400000,0x60009519,0x7c00100,0x220400,0x60009519,0x7c00100,0x250400,0x6000a008,
+0x7c00100,0x220400,0x6000a008,0x7c00100,0x250400,0x6000c300,0x4000000,0x3a703580,0x6000c654,0x2802000,0x962460,0x6000c654,0x4000010,0x200000,0x6000c654,0x7c00100,
+0x230400,0x6000c73f,0x2802000,0x962460,0x6000c73f,0x2802100,0x962460,0x6000c73f,0x4000000,0x200000,0x6000c73f,0x6800100,0x962540,0x6000c73f,0x6804000,0x962540,
+0x6000c73f,0x7c00100,0x230400,0x6000c80b,0x7c00100,0x230400,0x6000c941,0x2802100,0x962460,0x6000c941,0x2806000,0x962460,0x6000c941,0x4000000,0x200000,0x6000c941,
+0x4000010,0x200000,0x6000c941,0x6800000,0x1329800,0x6000c941,0x6800100,0x962540,0x6000c941,0x7c00100,0x230400,0x6000c941,0xc000010,0x448000,0x6000ca82,0x7c00100,
+0x230400,0x6000cc00,0x4000000,0x4e00000,0x6000d000,0x4000000,0x200000,0x6002c300,0x4000000,0x100000,0x6002c300,0x4000000,0x10000d,0x6002c300,0x4000100,0x150400,
+0x6002c300,0x4000100,0x15040d,0x6002c300,0x4000100,0x14150400,0x600a3000,0x24000000,0x34200000,0x600a3000,0x24000000,0x34e00000,0x600a3700,0x24000000,0x34200000,0x600a3800,
+0x24000000,0x34200000,0x600a3800,0x24000000,0xb6800000,0x600a4305,0x7c00100,0xe30400,0x600ac300,0x4000000,0x34100000,0x600ac400,0x4000000,0x14e0000d,0x600ac400,0x4000000,
+0x34e0000d,0x600acb14,0x7c00100,0xe30000,0x600acb16,0x7c00100,0xe30c00,0x600acc00,0x4000000,0x34e00000,0x600acd00,0x4000000,0x34200000,0x600acd00,0x4000000,0x34e00000,
+0x600acd00,0x4000000,0xb6800000,0x600ace00,0x4000000,0x34e00000,0x600ace00,0x4000000,0xb6800000,0x600acf00,0x4000000,0x34e00000,0x600acf00,0x4000000,0xb6800000,0x600ad111,
+0x7c40300,0xe30000,0x604ac4ab,0x4000000,0x34e00003,0x61000a03,0x4000000,0x1600000,0x61000c02,0x80000000,0x218960,0x6100120f,0x4000000,0x200000,0x61001a18,0x7c00100,
+0x1830000,0x61001d0c,0x7c00100,0x220400,0x61001d0c,0x7c00100,0x250400,0x61006600,0x24000020,0x200000,0x61008407,0x7c00100,0x220400,0x61008407,0x7c00100,0x250400,
+0x6100870c,0x7c00100,0x220400,0x61008e00,0x24000000,0x200000,0x61008e00,0x24000000,0x400000,0x61008e00,0x24000002,0x300000,0x6100903c,0x7c00100,0x230400,0x61009519,
+0x7c00100,0x220400,0x61009519,0x7c00100,0x250400,0x61009519,0x7c00500,0x22040f,0x61009b71,0x2802100,0x962460,0x61009b71,0x2806400,0x962460,0x61009b71,0x7c00100,
+0x230400,0x6100a008,0x2802100,0x962460,0x6100c300,0x4000000,0x20000f,0x6100cd00,0x4000000,0x200000,0x6100d202,0x2802400,0x962460,0x6100d202,0x2802500,0x962460,
+0x6100d202,0x7c00100,0x230400,0x6100d302,0x4000020,0x200000,0x6100d302,0x7c00120,0x230405,0x6100d476,0x2802100,0x962460,0x6100d476,0x2802100,0x962461,0x6100d476,
+0x2806400,0x962460,0x6100d476,0x4000000,0x400000,0x6100d476,0x6800000,0x1329800,0x6100d476,0x6800100,0x962540,0x6100d476,0x7c00100,0x230400,0x6100d476,0xc000010,
+0x448000,0x6100d573,0x2802100,0x962460,0x6100d573,0x2806400,0x962460,0x6100d573,0x6800100,0x962540,0x6100d573,0x7c00100,0x230400,0x6100d573,0x7c00900,0x230400,
+0x6100d573,0xc000010,0x448000,0x6100d68d,0x7c00100,0x230400,0x6100d756,0x7c00100,0x230400,0x6100d85c,0x2802400,0x962460,0x6100d85c,0x6800100,0x962540,0x6100d85c,
+0x7c00100,0x230400,0x6100d85c,0x7c00500,0x230400,0x6100d997,0x2802100,0x962460,0x6100d997,0x4000000,0x200000,0x6100d997,0x4000000,0x400000,0x6100d997,0x6800000,
+0x1329800,0x6100d997,0x6800100,0x962540,0x6100d997,0x6804400,0x962540,0x6100d997,0x7c00100,0x230400,0x6100d997,0x7c00100,0x230560,0x6100d997,0xc000010,0x448000,
+0x6100da98,0x6800000,0x1329800,0x6100da98,0x7c00100,0x230400,0x6100db71,0x4000000,0x200000,0x6100dc99,0x2802100,0x962460,0x6100dc99,0x2802400,0x962460,0x6100dc99,
+0x6800000,0x1329800,0x6100dc99,0x6800100,0x962540,0x6100dc99,0x6804400,0x962540,0x6100dc99,0x7c00100,0x230400,0x610a4711,0x7c40300,0xe30000,0x610a4f11,0x7c00300,
+0xe30001,0x610ace00,0x4000000,0x34e00000,0x6140af90,0x6800100,0x962540,0x6140af92,0x7c00100,0x230400,0x6180af8d,0x2802400,0x962460,0x62002a00,0x4000000,0x1600000,
+0x63002800,0x80000,0x918820,0x63c00c15,0x80000,0x918820,0x7000080e,0x7c00100,0x250400,0x70000a03,0x4000000,0x200000,0x70000c00,0x80000000,0x218960,0x70000f0a,
 0x7c00100,0x230400,0x70001004,0x7c00100,0x230400,0x70001524,0x2802100,0x962460,0x70001524,0x7c00100,0x230400,0x70001615,0x2802100,0x962460,0x7000171a,0x2802100,
 0x962460,0x70001821,0x6800000,0x1329800,0x70002320,0x7c00100,0x230400,0x70002a00,0x4000000,0x1500000,0x70002a00,0x4000000,0x1600000,0x70003000,0x24000000,0x200000,
-0x70003000,0x24000000,0x10200000,0x70003800,0x24000000,0xe00000,0x70005201,0x2802400,0x962460,0x7000581e,0x7c00100,0x230400,0x70006108,0x7c00100,0x220400,0x70006108,
+0x70003000,0x24000000,0x14200000,0x70003800,0x24000000,0x4e00000,0x70005201,0x2802400,0x962460,0x7000581e,0x7c00100,0x230400,0x70006108,0x7c00100,0x220400,0x70006108,
 0x7c00100,0x250400,0x70006f30,0x7c00100,0x230400,0x70007300,0x24000000,0x200000,0x70007f0e,0x4000000,0x200000,0x70008301,0x2802100,0x962460,0x70008301,0x2802400,
 0x962460,0x70008e00,0x24000000,0x200000,0x70008e00,0x24000000,0x400000,0x70008e00,0x24000002,0x400000,0x70008e00,0x24000008,0x1410000,0x70008e00,0x24000010,0x400000,
 0x70008e00,0x2c000010,0x448000,0x70009519,0x7c00100,0x220400,0x70009519,0x7c00100,0x230400,0x70009519,0x7c00100,0x250400,0x70009865,0x7c00100,0x230400,0x70009965,
 0x4000010,0x400000,0x70009965,0x7c00100,0x230400,0x7000a008,0x7c00100,0x220400,0x7000a008,0x7c00100,0x250400,0x7000a008,0x7c00500,0x22040f,0x7000a50e,0x4000000,
 0x200000,0x7000b61c,0x2802400,0x1862460,0x7000b61c,0x6800400,0x1862400,0x7000b61c,0x7c00100,0x1830000,0x7000c300,0x4000000,0x100000,0x7000c941,0x2806000,0x962460,
-0x7000cc00,0x4000000,0xe00000,0x7000cd00,0x4000000,0x200000,0x7000cd00,0x4000000,0xe00000,0x7000cd00,0x4000000,0x10200000,0x7000cd00,0x4000000,0x10e00000,0x7000cd00,
-0x4000000,0x10e05200,0x7000cd00,0x4000000,0x928045a0,0x7000cf00,0x4000000,0xe00000,0x7000cf00,0x4000000,0x10e00000,0x7000d202,0x2802100,0x962460,0x7000d202,0x7c00100,
+0x7000cc00,0x4000000,0x4e00000,0x7000cd00,0x4000000,0x200000,0x7000cd00,0x4000000,0x4200000,0x7000cd00,0x4000000,0x4e00000,0x7000cd00,0x4000000,0x14200000,0x7000cd00,
+0x4000000,0x14e00000,0x7000cd00,0x4000000,0x96800000,0x7000cf00,0x4000000,0x4e00000,0x7000cf00,0x4000000,0x14e00000,0x7000d202,0x2802100,0x962460,0x7000d202,0x7c00100,
 0x230400,0x7000d997,0x7c00100,0x230400,0x7000d997,0xc000010,0x248000,0x7000dd86,0x2802400,0x962460,0x7000dd86,0x7c00100,0x230400,0x7000dd86,0xc000010,0x448000,
 0x7000de9f,0x4000000,0x200000,0x7000de9f,0x7c00100,0x230400,0x7000e001,0x2000,0x962460,0x7000e001,0x2802400,0x962460,0x7000e187,0x2802000,0x962460,0x7000e187,
 0x2802100,0x962460,0x7000e187,0x4000000,0x200000,0x7000e187,0x7c00100,0x230400,0x7000e187,0xc000010,0x448000,0x7000e288,0x7c00100,0x230400,0x7000e300,0x4000000,
@@ -3562,21 +3632,21 @@ static const uint32_t propsVectors[6375]={
 0x200000,0x7000f8a6,0x6800100,0x962540,0x7000f8a6,0x6800100,0x962541,0x7000f8a6,0x7c00100,0x230400,0x7000f8a6,0xc000010,0x448000,0x7000f921,0x4000000,0x200000,
 0x7000fa00,0x4000000,0x200000,0x7000fb9e,0x2802100,0x962460,0x7000fb9e,0x2802400,0x962460,0x7000fb9e,0x2806400,0x962460,0x7000fb9e,0x4000000,0x200000,0x7000fb9e,
 0x6800000,0x1329800,0x7000fb9e,0x6800100,0x962540,0x7000fb9e,0x6800100,0x962541,0x7000fb9e,0x7c00100,0x230400,0x7000fc92,0x4000000,0x200000,0x7000fc92,0x6800000,
-0x1329800,0x7000fc92,0x7c00100,0x220400,0x7000fc92,0x7c00100,0x230400,0x7000fc92,0x7c00100,0x250400,0x700acd00,0x4000000,0x30e00000,0x700acd00,0x4000000,0xb28045a0,
-0x700ace00,0x4000000,0x30e00000,0x700acf00,0x4000000,0x30e00000,0x700acf00,0x4000000,0xb28045a0,0x7040dfc0,0x4000000,0x200000,0x7040f7c4,0x80000,0x918820,0x7080af7b,
-0x2802400,0x962460,0x7080dfc0,0x2802400,0x962460,0x70c0e4c2,0x2802100,0x962460,0x70c0e4c2,0x2802400,0x962460,0x70c0e4c2,0x6800100,0x962540,0x8000120f,0x7c00100,
+0x1329800,0x7000fc92,0x7c00100,0x220400,0x7000fc92,0x7c00100,0x230400,0x7000fc92,0x7c00100,0x250400,0x700acd00,0x4000000,0x34e00000,0x700acd00,0x4000000,0xb6800000,
+0x700ace00,0x4000000,0x34e00000,0x700acf00,0x4000000,0x34e00000,0x700acf00,0x4000000,0xb6800000,0x7040dfe5,0x4000000,0x200000,0x7040f7e9,0x80000,0x918820,0x7080af90,
+0x2802400,0x962460,0x7080dfe5,0x2802400,0x962460,0x70c0e4e7,0x2802100,0x962460,0x70c0e4e7,0x2802400,0x962460,0x70c0e4e7,0x6800100,0x962540,0x8000120f,0x7c00100,
 0x230400,0x80001524,0x7c00100,0x230400,0x8000171a,0x7c00100,0x230400,0x80002006,0x7c00100,0x220400,0x80002006,0x7c00100,0x250400,0x80002a00,0x4000000,0x1500000,
 0x80002d00,0x4000000,0x200000,0x80005208,0x2802400,0x962460,0x80005c00,0x4000000,0x200000,0x80007300,0x24000000,0x200000,0x80009519,0x7c00100,0x220400,0x80009519,
 0x7c00100,0x230400,0x80009519,0x7c00100,0x250400,0x80009865,0x7c00100,0x230400,0x8000a008,0x2802100,0x962460,0x8000b30a,0x4000000,0x500000,0x8000b30a,0x7c00100,
-0x230400,0x8000cd00,0x4000000,0xe00000,0x8000d202,0x2802500,0x962460,0x8000d202,0x7c00100,0x230400,0x8000d68d,0x4000000,0x200000,0x8000d997,0x2802400,0x962460,
-0x8000d997,0x4000000,0x200000,0x8000d997,0x4000000,0x400000,0x8000d997,0x4000000,0x500000,0x8000d997,0x7c00100,0x230400,0x8000d997,0xc000010,0x448000,0x8000e489,
+0x230400,0x8000cd00,0x4000000,0x4e00000,0x8000d202,0x2802500,0x962460,0x8000d202,0x7c00100,0x230400,0x8000d68d,0x4000000,0x200000,0x8000d997,0x2802000,0x962460,
+0x8000d997,0x2802400,0x962460,0x8000d997,0x4000000,0x400000,0x8000d997,0x4000000,0x500000,0x8000d997,0x7c00100,0x230400,0x8000d997,0xc000010,0x448000,0x8000e489,
 0x2802100,0x962460,0x8000e489,0x7c00100,0x230400,0x8000e719,0x7c00100,0x220400,0x8000f8a6,0x2802100,0x962460,0x8000f8a6,0x7c00100,0x230400,0x8000f8a6,0xc000010,
 0x448000,0x8000fda1,0x2802100,0x1862460,0x8000fda1,0x2806400,0x1862460,0x8000fda1,0x4000000,0x1800000,0x8000fda1,0x6800000,0x1329800,0x8000fda1,0x6800100,0x1862540,
 0x8000fda1,0x7c00100,0x1830000,0x8000fda1,0xc000010,0x448000,0x8000fe9c,0x7c00100,0x230400,0x8000fe9c,0x7c00100,0x830400,0x8000fe9c,0x7c00100,0x1430400,0x8000ff06,
 0x7c00100,0x220400,0x80010165,0x7c00100,0x230400,0x800102a2,0x4000000,0x200000,0x800102a2,0x7c00100,0x230400,0x800103a4,0x7c00100,0x230400,0x800103a4,0xc000010,
 0x448000,0x8001044c,0x4000000,0x200000,0x8001044c,0x7c00100,0x220400,0x8001044c,0x7c00100,0x250400,0x80010670,0x2802000,0x962460,0x80010670,0x4000000,0x200000,
-0x80010670,0x4000010,0x400000,0x80010670,0xc000010,0x448000,0x800a4711,0x7c40300,0xe30000,0x800acd00,0x4000000,0x30e00000,0x800acd00,0x4000000,0x7a904de0,0x800ace00,
-0x4000000,0x30e00000,0x800acf00,0x4000000,0x30e00000,0x800b0011,0x7c40300,0xe30000,0x800b0500,0x4000000,0x30e00000,0x800b0500,0x4000000,0xb28045a0,0x90001615,0x7c00100,
+0x80010670,0x4000010,0x400000,0x80010670,0xc000010,0x448000,0x800a4711,0x7c40300,0xe30000,0x800acd00,0x4000000,0x34e00000,0x800acd00,0x4000000,0x7a902460,0x800ace00,
+0x4000000,0x34e00000,0x800acf00,0x4000000,0x34e00000,0x800b0011,0x7c40300,0xe30000,0x800b0500,0x4000000,0x34e00000,0x800b0500,0x4000000,0xb6800000,0x90001615,0x7c00100,
 0x230400,0x9000171a,0x4000000,0x200000,0x9000171a,0x7c00100,0x230400,0x90003000,0x24000000,0x200000,0x90007f0e,0x4000000,0x200000,0x90008301,0x2802000,0x962460,
 0x90008e00,0x24000000,0x400000,0x90009519,0x7c00100,0x250400,0x9000a16f,0x2802100,0x962460,0x9000d200,0x80000000,0x218960,0x9000d202,0x2802000,0x962460,0x9000d202,
 0x2802100,0x962460,0x9000d202,0x7c00100,0x230400,0x9000e59d,0x2802100,0x962460,0x900107a7,0x2802100,0x962460,0x900107a7,0x2802400,0x962460,0x900107a7,0x2802c00,
@@ -3586,37 +3656,52 @@ static const uint32_t propsVectors[6375]={
 0x962460,0x90010ca9,0x4000000,0x500000,0x90010ca9,0x4000010,0xb00000,0x90010ca9,0x6800100,0x962540,0x90010ca9,0x7c00100,0x230400,0x90010d1b,0x4000000,0x500000,
 0x90010eaa,0x2802100,0x962460,0x90010eaa,0x2802400,0x962460,0x90010eaa,0x2806400,0x962460,0x90010eaa,0x4000000,0x200000,0x90010eaa,0x4000000,0x400000,0x90010eaa,
 0x4000010,0x400000,0x90010eaa,0x6800000,0x1329800,0x90010eaa,0x6800100,0x962540,0x90010eaa,0x7c00100,0x230400,0x90010eaa,0xc000010,0x448000,0x90010fab,0x7c00100,
-0x220400,0x90010fab,0x7c00100,0x250400,0x9002c300,0x4000000,0x100000,0x900ac400,0x4000000,0xe0000d,0x900acd00,0x4000000,0x30e00000,0x900acd00,0x4000000,0xb28045a0,
-0x900acf00,0x4000000,0x30e00000,0x900b0500,0x4000000,0xe00000,0x900b0500,0x4000000,0x30e00000,0x900b0500,0x4000000,0xb28045a0,0x900b0b9a,0x7c00900,0x1230400,0x900b109a,
+0x220400,0x90010fab,0x7c00100,0x250400,0x9002c300,0x4000000,0x100000,0x900ac400,0x4000000,0xe0000d,0x900acd00,0x4000000,0x34e00000,0x900acd00,0x4000000,0xb6800000,
+0x900acf00,0x4000000,0x34e00000,0x900b0500,0x4000000,0xe00000,0x900b0500,0x4000000,0x34e00000,0x900b0500,0x4000000,0xb6800000,0x900b0b9a,0x7c00900,0x1230400,0x900b109a,
 0x7c00300,0xe30000,0x900b119a,0x7c00300,0xe30000,0x90408e06,0x24000000,0x400000,0xa0001004,0x4000000,0x200000,0xa0001004,0x7c00100,0x230400,0xa000120f,0x2802100,
 0x962460,0xa000120f,0x2802400,0x962460,0xa000171a,0x2802100,0x962460,0xa000171a,0x2806400,0x962460,0xa0002a00,0x4000000,0x1600000,0xa0003000,0x24000000,0x200000,
-0xa000581e,0x7c00100,0x230400,0xa0007300,0x24000000,0x200000,0xa0008301,0x2802400,0x962460,0xa0008e00,0x24000000,0x400000,0xa000cf00,0x4000000,0xe00000,0xa0010500,
+0xa000581e,0x7c00100,0x230400,0xa0007300,0x24000000,0x200000,0xa0008301,0x2802400,0x962460,0xa0008e00,0x24000000,0x400000,0xa000cf00,0x4000000,0x4e00000,0xa0010500,
 0x4000000,0x200000,0xa00114af,0x2802100,0x962460,0xa00114af,0x2802400,0x962460,0xa00114af,0x2806400,0x962460,0xa00114af,0x6800000,0x1329800,0xa00114af,0x7c00100,
 0x230400,0xa00114af,0x7c00100,0x230560,0xa00116b0,0x2802100,0x962460,0xa00116b0,0x2802800,0x962460,0xa00116b0,0x2806400,0x962460,0xa00116b0,0x4000000,0x400000,
 0xa00116b0,0x4000000,0x500000,0xa00116b0,0x4000010,0x400000,0xa00116b0,0x6800100,0x962540,0xa00116b0,0x7c00100,0x230400,0xa00116b0,0x7c00100,0x230560,0xa00116b0,
 0xc000010,0x448000,0xa0011722,0x7c00100,0x230400,0xa00118b1,0x2802000,0x962460,0xa00118b1,0x2802100,0x962460,0xa00118b1,0x2806400,0x962460,0xa00118b1,0x4000000,
 0x200000,0xa00118b1,0x4000000,0x400000,0xa00118b1,0x4000000,0x500000,0xa00118b1,0x6800100,0x962540,0xa00118b1,0x7c00100,0x230400,0xa00118b1,0x7c00100,0x230560,
-0xa00118b1,0xc000010,0x448000,0xa00a4005,0x7c00100,0xe30400,0xa00a4711,0x7c40300,0xe30000,0xa00ac400,0x4000000,0xe00000,0xa00acb14,0x7c00100,0xe30000,0xa00acf00,
-0x4000000,0x30e00000,0xa00b0500,0x4000000,0x30e00000,0xa00b0500,0x4000000,0xb28045a0,0xa00b0b96,0x7c00900,0x1230400,0xa00b1211,0x7c40300,0xe30000,0xa00b1314,0x7c00100,
-0xe30000,0xa00b1596,0x7c00300,0xe30000,0xa040af86,0x6800400,0x962540};
+0xa00118b1,0xc000010,0x448000,0xa00a4005,0x7c00100,0xe30400,0xa00a4711,0x7c40300,0xe30000,0xa00ac400,0x4000000,0x4e00000,0xa00acb14,0x7c00100,0xe30000,0xa00acf00,
+0x4000000,0x34e00000,0xa00b0500,0x4000000,0x34e00000,0xa00b0500,0x4000000,0xb6800000,0xa00b0b96,0x7c00900,0x1230400,0xa00b1211,0x7c40300,0xe30000,0xa00b1314,0x7c00100,
+0xe30000,0xa00b1596,0x7c00300,0xe30000,0xa040af9c,0x6800400,0x962540,0xb0000a03,0x7c00100,0x220400,0xb0000b13,0x7c00100,0x2633800,0xb0001004,0x2802000,0x962460,
+0xb0001110,0x4000000,0x200000,0xb0001524,0x2802000,0x962460,0xb0001615,0x4000000,0x500000,0xb000251b,0x7c00100,0x230400,0xb0007300,0x24000000,0x200000,0xb0008939,
+0x4000000,0x200000,0xb0008939,0x7c00100,0x230400,0xb0008e00,0x24000000,0x200000,0xb0008e00,0x24000000,0x400000,0xb0008e00,0x24000010,0x400000,0xb0009257,0x2802000,
+0x962460,0xb0009257,0x4000000,0x1600000,0xb0009519,0x7c00100,0x220400,0xb0009519,0x7c00100,0x250400,0xb0009a00,0x4000000,0x200000,0xb000b30a,0x2802000,0x962460,
+0xb000b30a,0x7c00100,0x230400,0xb000c178,0x80000000,0x218960,0xb000c300,0x4000000,0x4200000,0xb000d202,0x2802000,0x962460,0xb000d476,0x6800100,0x962540,0xb000d476,
+0x7c00100,0x230400,0xb000e300,0x4000000,0x4e00000,0xb000fda1,0x7c00100,0x1830000,0xb0010eaa,0x2802000,0x962460,0xb00116b0,0x7c00100,0x230400,0xb0011900,0x4000000,
+0x4e00000,0xb0011ab2,0x2802100,0x962460,0xb0011ab2,0x2802400,0x962460,0xb0011ab2,0x2806400,0x962460,0xb0011ab2,0x4000000,0x200000,0xb0011ab2,0x6800100,0x962540,
+0xb0011ab2,0x7c00100,0x230400,0xb0011b0c,0x7c00100,0x250400,0xb0011cb3,0x2802100,0x962460,0xb0011cb3,0x2806400,0x962460,0xb0011cb3,0x6800000,0x1329800,0xb0011cb3,
+0x6800100,0x962540,0xb0011cb3,0x7c00100,0x230400,0xb0011db6,0x2802500,0x962460,0xb0011db6,0x6800000,0x1329800,0xb0011db6,0x7c00100,0x230400,0xb0011db6,0x7c00500,
+0x230400,0xb0011e00,0x4000000,0x200000,0xb0011e00,0x4000000,0x1500000,0xb0011fb4,0x2802100,0x962460,0xb0011fb4,0x6800100,0x962540,0xb0011fb4,0x7c00100,0x230400,
+0xb0011fb4,0xc000010,0x248000,0xb0012000,0x4000000,0x200000,0xb00121b5,0x4000000,0x200000,0xb00121b5,0x4000010,0x400000,0xb00121b5,0x7c00100,0x220400,0xb00121b5,
+0x7c00100,0x250400,0xb00121b5,0xc000010,0x448000,0xb00122b8,0x4000000,0x200000,0xb00122b8,0x7c00100,0x230400,0xb00123b7,0x2802400,0x962460,0xb00123b7,0x4000000,
+0x200000,0xb00123b7,0x7c00100,0x230400,0xb00123b7,0xc000010,0x248000,0xb00a4005,0x7c00100,0xe30400,0xb00a4711,0x7c40300,0xe30000,0xb00acf00,0x4000000,0x34e00000,
+0xb00b0500,0x4000000,0x34e00000,0xb00b0500,0x4000000,0x3ce00000,0xb00b0500,0x4000000,0xb6800000,0xb00b109a,0x7c00300,0xe30000,0xb080e47a,0x2802000,0x962460};
 
-static const int32_t countPropsVectors=6375;
+static const int32_t countPropsVectors=6639;
 static const int32_t propsVectorsColumns=3;
-static const uint16_t scriptExtensions[198]={
+static const uint16_t scriptExtensions[234]={
 0x800e,0x8019,8,0x8059,8,2,8,0x8038,8,6,8,0x8019,3,0x800c,2,0x22,
-0x8025,2,0xe,2,0x22,0x54,0x79,0x7b,0x80a7,2,0x8022,2,0x8025,2,0x1b,4,
-0xa,0xf,0x10,0x15,0x19,0x1a,0x1f,0x23,0x24,0x89,0x8097,4,0xa,0xf,0x10,0x15,
-0x19,0x1a,0x1f,0x23,0x24,0x8089,4,0xa,0xf,0x10,0x15,0x1a,0x1f,0x21,0x23,0x24,
-0x3a,0x89,0x91,0x99,0x9e,0x80a0,4,0xa,0xf,0x10,0x15,0x1a,0x1f,0x21,0x23,0x24,
-0x30,0x3a,0x89,0x91,0x99,0x9e,0x80a0,0xa,0x78,0x80a0,0xa,0x57,4,0x3a,0x8076,4,
-0x5c,0x10,0x80a4,0x10,0x61,0xf,0x809d,0xf,0x65,0x23,0x8089,0x23,0x69,0x1c,0x34,0x8076,
-0x1c,0x6d,0xc,0x8019,0x2a,0x2b,0x2c,0x802d,0x1b,0x805a,0x800a,0xa,0x8089,0xa,0x8097,0xa,
-0x15,0x1a,0x23,0x8024,0xa,0x8015,0x8004,0xa,0x19,0x8089,5,0x11,0x12,0x14,0x16,0x8029,
-5,0x11,0x12,0x14,0x8016,0x8011,5,0x8011,0x11,0x14,0x8016,0xa,0xf,0x10,0x15,0x78,
-0x91,0x99,0x9e,0xa0,0x80a3,0xa,0xf,0x10,0x78,0x91,0x99,0x9e,0xa0,0x80a3,4,0x800a,
-0xa,0xae,0xa,0x8023,0xa,0xb2,0x19,0x1c,0x804f,0x37,0x804e,0x2f,0x31,0x8053,0x2f,0x8031,
-2,0x8007,0x89,0x69,0x8087,0};
+0x25,0x80b6,2,0x22,0x8025,2,0x12,2,0x22,0x54,0x79,0x7b,0xa7,0xb6,0x80b7,2,
+0x8022,2,0x8025,2,0x21,2,0x80b6,2,0x25,4,0xa,0xf,0x10,0x15,0x19,0x1a,
+0x1f,0x23,0x24,0x89,0x97,0x809e,4,0xa,0xf,0x10,0x15,0x19,0x1a,0x1f,0x23,0x24,
+0x89,0x809e,4,0xa,0xf,0x10,0x15,0x1a,0x1f,0x21,0x23,0x24,0x3a,0x89,0x91,0x99,
+0x9e,0xa0,0xb2,0x80b3,4,0xa,0xf,0x10,0x15,0x1a,0x1f,0x21,0x23,0x24,0x30,0x3a,
+0x89,0x91,0x99,0x9e,0xa0,0xb2,0x80b3,0xa,0x78,0xa0,0x80b2,0xa,0x67,4,0x3a,0x8076,
+4,0x6d,0x10,0x80a4,0x10,0x72,0xf,0x809d,0xf,0x76,0x23,0x8089,0x23,0x7a,0x1c,0x34,
+0x8076,0x1c,0x7e,0xc,0x8019,0x2a,0x2b,0x2c,0x802d,0x1b,0x805a,0x800a,4,0xa,0x15,0x8089,
+0xa,0x8089,4,0x800a,0xa,0x8097,0xa,0x15,0x1a,0x1f,0x23,0x8024,0x8004,0xa,0x19,0x8089,
+5,0x11,0x12,0x14,0x16,0x8029,5,0x11,0x12,0x14,0x8016,0x8011,5,0x8011,0x11,0x14,
+0x8016,0xa,0xf,0x10,0x78,0x91,0x99,0x9d,0x9e,0xa0,0xa3,0x80b2,0xa,0xf,0x10,0x15,
+0x1a,0x78,0x91,0x99,0x9d,0x9e,0xa0,0xa3,0x80b2,0xa,0xf,0x10,0x15,0x78,0x91,0x99,
+0x9d,0x9e,0xa0,0xa3,0x80b2,0xa,0x92,0xa,0x8023,0xa,0xd7,0x19,0x1c,0x804f,0x37,0x804e,
+0x2f,0x31,0x8053,0x2f,0x8031,2,0x8007,0x89,0x7a,0x8087};
 
-static const int32_t indexes[UPROPS_INDEX_COUNT]={0x2962,0x2962,0x2962,0x2962,0x6280,3,0x7b67,0x7bca,0x7bca,0x7bca,0xb18b1,0x2a75631,0,0,0,0};
+static const int32_t indexes[UPROPS_INDEX_COUNT]={0x29fa,0x29fa,0x29fa,0x29fa,0x649c,3,0x7e8b,0x7f00,0x7f00,0x7f00,0xb23b8,0x2a75a31,0,0,0,0};
 
 #endif  // INCLUDED_FROM_UCHAR_C
diff --git a/deps/icu-small/source/common/ucln_cmn.h b/deps/icu-small/source/common/ucln_cmn.h
index 5db94945172c3d..9b6c2058135c52 100644
--- a/deps/icu-small/source/common/ucln_cmn.h
+++ b/deps/icu-small/source/common/ucln_cmn.h
@@ -33,6 +33,7 @@ Please keep the order of enums declared in same order
 as the cleanup functions are suppose to be called. */
 typedef enum ECleanupCommonType {
     UCLN_COMMON_START = -1,
+    UCLN_COMMON_NUMPARSE_UNISETS,
     UCLN_COMMON_USPREP,
     UCLN_COMMON_BREAKITERATOR,
     UCLN_COMMON_RBBI,
diff --git a/deps/icu-small/source/common/ucnv_bld.cpp b/deps/icu-small/source/common/ucnv_bld.cpp
index 482034fd0c1b03..1a1625d69c8c79 100644
--- a/deps/icu-small/source/common/ucnv_bld.cpp
+++ b/deps/icu-small/source/common/ucnv_bld.cpp
@@ -261,6 +261,11 @@ static UBool U_CALLCONV ucnv_cleanup(void) {
     return (SHARED_DATA_HASHTABLE == NULL);
 }
 
+U_CAPI void U_EXPORT2
+ucnv_enableCleanup() {
+    ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
+}
+
 static UBool U_CALLCONV
 isCnvAcceptable(void * /*context*/,
                 const char * /*type*/, const char * /*name*/,
@@ -439,7 +444,7 @@ ucnv_shareConverterData(UConverterSharedData * data)
         SHARED_DATA_HASHTABLE = uhash_openSize(uhash_hashChars, uhash_compareChars, NULL,
                             ucnv_io_countKnownConverters(&err)*UCNV_CACHE_LOAD_FACTOR,
                             &err);
-        ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
+        ucnv_enableCleanup();
 
         if (U_FAILURE(err))
             return;
@@ -1099,7 +1104,7 @@ static void U_CALLCONV initAvailableConvertersList(UErrorCode &errCode) {
     U_ASSERT(gAvailableConverterCount == 0);
     U_ASSERT(gAvailableConverters == NULL);
 
-    ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
+    ucnv_enableCleanup();
     UEnumeration *allConvEnum = ucnv_openAllNames(&errCode);
     int32_t allConverterCount = uenum_count(allConvEnum, &errCode);
     if (U_FAILURE(errCode)) {
@@ -1205,7 +1210,7 @@ internalSetName(const char *name, UErrorCode *status) {
     //             -- Andy
     gDefaultConverterName = gDefaultConverterNameBuffer;
 
-    ucln_common_registerCleanup(UCLN_COMMON_UCNV, ucnv_cleanup);
+    ucnv_enableCleanup();
 
     umtx_unlock(&cnvCacheMutex);
 }
diff --git a/deps/icu-small/source/common/ucnv_bld.h b/deps/icu-small/source/common/ucnv_bld.h
index 16dd14408a7504..caa263f56d938b 100644
--- a/deps/icu-small/source/common/ucnv_bld.h
+++ b/deps/icu-small/source/common/ucnv_bld.h
@@ -288,6 +288,9 @@ ucnv_swap(const UDataSwapper *ds,
           const void *inData, int32_t length, void *outData,
           UErrorCode *pErrorCode);
 
+U_CAPI void U_EXPORT2
+ucnv_enableCleanup();
+
 #endif
 
 #endif /* _UCNV_BLD */
diff --git a/deps/icu-small/source/common/ucurr.cpp b/deps/icu-small/source/common/ucurr.cpp
index d1e5f62a9a76bb..bfde3a9df9c2d1 100644
--- a/deps/icu-small/source/common/ucurr.cpp
+++ b/deps/icu-small/source/common/ucurr.cpp
@@ -16,10 +16,14 @@
 #include "unicode/ures.h"
 #include "unicode/ustring.h"
 #include "unicode/parsepos.h"
+#include "unicode/uniset.h"
+#include "unicode/usetiter.h"
+#include "unicode/utf16.h"
 #include "ustr_imp.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
+#include "static_unicode_sets.h"
 #include "uassert.h"
 #include "umutex.h"
 #include "ucln_cmn.h"
@@ -65,14 +69,6 @@ static const int32_t POW10[] = { 1, 10, 100, 1000, 10000, 100000,
 
 static const int32_t MAX_POW10 = UPRV_LENGTHOF(POW10) - 1;
 
-// Defines equivalent currency symbols.
-static const char *EQUIV_CURRENCY_SYMBOLS[][2] = {
-    {"\\u00a5", "\\uffe5"},
-    {"$", "\\ufe69"},
-    {"$", "\\uff04"},
-    {"\\u20a8", "\\u20b9"},
-    {"\\u00a3", "\\u20a4"}};
-
 #define ISO_CURRENCY_CODE_LENGTH 3
 
 //------------------------------------------------------------
@@ -1287,17 +1283,28 @@ static void
 linearSearch(const CurrencyNameStruct* currencyNames,
              int32_t begin, int32_t end,
              const UChar* text, int32_t textLen,
+             int32_t *partialMatchLen,
              int32_t *maxMatchLen, int32_t* maxMatchIndex) {
+    int32_t initialPartialMatchLen = *partialMatchLen;
     for (int32_t index = begin; index <= end; ++index) {
         int32_t len = currencyNames[index].currencyNameLen;
         if (len > *maxMatchLen && len <= textLen &&
             uprv_memcmp(currencyNames[index].currencyName, text, len * sizeof(UChar)) == 0) {
+            *partialMatchLen = MAX(*partialMatchLen, len);
             *maxMatchIndex = index;
             *maxMatchLen = len;
 #ifdef UCURR_DEBUG
             printf("maxMatchIndex = %d, maxMatchLen = %d\n",
                    *maxMatchIndex, *maxMatchLen);
 #endif
+        } else {
+            // Check for partial matches.
+            for (int32_t i=initialPartialMatchLen; i<MIN(len, textLen); i++) {
+                if (currencyNames[index].currencyName[i] != text[i]) {
+                    break;
+                }
+                *partialMatchLen = MAX(*partialMatchLen, i + 1);
+            }
         }
     }
 }
@@ -1315,6 +1322,7 @@ static void
 searchCurrencyName(const CurrencyNameStruct* currencyNames,
                    int32_t total_currency_count,
                    const UChar* text, int32_t textLen,
+                   int32_t *partialMatchLen,
                    int32_t* maxMatchLen, int32_t* maxMatchIndex) {
     *maxMatchIndex = -1;
     *maxMatchLen = 0;
@@ -1344,6 +1352,7 @@ searchCurrencyName(const CurrencyNameStruct* currencyNames,
         if (binarySearchBegin == -1) { // did not find the range
             break;
         }
+        *partialMatchLen = MAX(*partialMatchLen, index + 1);
         if (matchIndex != -1) {
             // find an exact match for text from text[0] to text[index]
             // in currencyNames array.
@@ -1354,6 +1363,7 @@ searchCurrencyName(const CurrencyNameStruct* currencyNames,
             // linear search if within threshold.
             linearSearch(currencyNames, binarySearchBegin, binarySearchEnd,
                          text, textLen,
+                         partialMatchLen,
                          maxMatchLen, maxMatchIndex);
             break;
         }
@@ -1422,19 +1432,13 @@ currency_cache_cleanup(void) {
 }
 
 
-U_CAPI void
-uprv_parseCurrency(const char* locale,
-                   const icu::UnicodeString& text,
-                   icu::ParsePosition& pos,
-                   int8_t type,
-                   UChar* result,
-                   UErrorCode& ec)
-{
-    U_NAMESPACE_USE
-
-    if (U_FAILURE(ec)) {
-        return;
-    }
+/**
+ * Loads the currency name data from the cache, or from resource bundles if necessary.
+ * The refCount is automatically incremented.  It is the caller's responsibility
+ * to decrement it when done!
+ */
+static CurrencyNameCacheEntry*
+getCacheEntry(const char* locale, UErrorCode& ec) {
 
     int32_t total_currency_name_count = 0;
     CurrencyNameStruct* currencyNames = NULL;
@@ -1455,17 +1459,13 @@ uprv_parseCurrency(const char* locale,
     }
     if (found != -1) {
         cacheEntry = currCache[found];
-        currencyNames = cacheEntry->currencyNames;
-        total_currency_name_count = cacheEntry->totalCurrencyNameCount;
-        currencySymbols = cacheEntry->currencySymbols;
-        total_currency_symbol_count = cacheEntry->totalCurrencySymbolCount;
         ++(cacheEntry->refCount);
     }
     umtx_unlock(&gCurrencyCacheMutex);
     if (found == -1) {
         collectCurrencyNames(locale, &currencyNames, &total_currency_name_count, &currencySymbols, &total_currency_symbol_count, ec);
         if (U_FAILURE(ec)) {
-            return;
+            return NULL;
         }
         umtx_lock(&gCurrencyCacheMutex);
         // check again.
@@ -1500,20 +1500,50 @@ uprv_parseCurrency(const char* locale,
             cacheEntry->totalCurrencySymbolCount = total_currency_symbol_count;
             cacheEntry->refCount = 2; // one for cache, one for reference
             currentCacheEntryIndex = (currentCacheEntryIndex + 1) % CURRENCY_NAME_CACHE_NUM;
-            ucln_common_registerCleanup(UCLN_COMMON_CURRENCY, currency_cache_cleanup);
+            ucln_common_registerCleanup(UCLN_COMMON_CURRENCY, currency_cleanup);
         } else {
             deleteCurrencyNames(currencyNames, total_currency_name_count);
             deleteCurrencyNames(currencySymbols, total_currency_symbol_count);
             cacheEntry = currCache[found];
-            currencyNames = cacheEntry->currencyNames;
-            total_currency_name_count = cacheEntry->totalCurrencyNameCount;
-            currencySymbols = cacheEntry->currencySymbols;
-            total_currency_symbol_count = cacheEntry->totalCurrencySymbolCount;
             ++(cacheEntry->refCount);
         }
         umtx_unlock(&gCurrencyCacheMutex);
     }
 
+    return cacheEntry;
+}
+
+static void releaseCacheEntry(CurrencyNameCacheEntry* cacheEntry) {
+    umtx_lock(&gCurrencyCacheMutex);
+    --(cacheEntry->refCount);
+    if (cacheEntry->refCount == 0) {  // remove
+        deleteCacheEntry(cacheEntry);
+    }
+    umtx_unlock(&gCurrencyCacheMutex);
+}
+
+U_CAPI void
+uprv_parseCurrency(const char* locale,
+                   const icu::UnicodeString& text,
+                   icu::ParsePosition& pos,
+                   int8_t type,
+                   int32_t* partialMatchLen,
+                   UChar* result,
+                   UErrorCode& ec) {
+    U_NAMESPACE_USE
+    if (U_FAILURE(ec)) {
+        return;
+    }
+    CurrencyNameCacheEntry* cacheEntry = getCacheEntry(locale, ec);
+    if (U_FAILURE(ec)) {
+        return;
+    }
+
+    int32_t total_currency_name_count = cacheEntry->totalCurrencyNameCount;
+    CurrencyNameStruct* currencyNames = cacheEntry->currencyNames;
+    int32_t total_currency_symbol_count = cacheEntry->totalCurrencySymbolCount;
+    CurrencyNameStruct* currencySymbols = cacheEntry->currencySymbols;
+
     int32_t start = pos.getIndex();
 
     UChar inputText[MAX_CURRENCY_NAME_LEN];
@@ -1523,11 +1553,14 @@ uprv_parseCurrency(const char* locale,
     UErrorCode ec1 = U_ZERO_ERROR;
     textLen = u_strToUpper(upperText, MAX_CURRENCY_NAME_LEN, inputText, textLen, locale, &ec1);
 
+    // Make sure partialMatchLen is initialized
+    *partialMatchLen = 0;
+
     int32_t max = 0;
     int32_t matchIndex = -1;
     // case in-sensitive comparision against currency names
     searchCurrencyName(currencyNames, total_currency_name_count,
-                       upperText, textLen, &max, &matchIndex);
+                       upperText, textLen, partialMatchLen, &max, &matchIndex);
 
 #ifdef UCURR_DEBUG
     printf("search in names, max = %d, matchIndex = %d\n", max, matchIndex);
@@ -1539,6 +1572,7 @@ uprv_parseCurrency(const char* locale,
         // case sensitive comparison against currency symbols and ISO code.
         searchCurrencyName(currencySymbols, total_currency_symbol_count,
                            inputText, textLen,
+                           partialMatchLen,
                            &maxInSymbol, &matchIndexInSymbol);
     }
 
@@ -1558,12 +1592,35 @@ uprv_parseCurrency(const char* locale,
     }
 
     // decrease reference count
-    umtx_lock(&gCurrencyCacheMutex);
-    --(cacheEntry->refCount);
-    if (cacheEntry->refCount == 0) {  // remove
-        deleteCacheEntry(cacheEntry);
+    releaseCacheEntry(cacheEntry);
+}
+
+void uprv_currencyLeads(const char* locale, icu::UnicodeSet& result, UErrorCode& ec) {
+    U_NAMESPACE_USE
+    if (U_FAILURE(ec)) {
+        return;
     }
-    umtx_unlock(&gCurrencyCacheMutex);
+    CurrencyNameCacheEntry* cacheEntry = getCacheEntry(locale, ec);
+    if (U_FAILURE(ec)) {
+        return;
+    }
+
+    for (int32_t i=0; i<cacheEntry->totalCurrencySymbolCount; i++) {
+        const CurrencyNameStruct& info = cacheEntry->currencySymbols[i];
+        UChar32 cp;
+        U16_GET(info.currencyName, 0, 0, info.currencyNameLen, cp);
+        result.add(cp);
+    }
+
+    for (int32_t i=0; i<cacheEntry->totalCurrencyNameCount; i++) {
+        const CurrencyNameStruct& info = cacheEntry->currencyNames[i];
+        UChar32 cp;
+        U16_GET(info.currencyName, 0, 0, info.currencyNameLen, cp);
+        result.add(cp);
+    }
+
+    // decrease reference count
+    releaseCacheEntry(cacheEntry);
 }
 
 
@@ -1729,7 +1786,8 @@ static const struct CurrencyList {
     {"BUK", UCURR_COMMON|UCURR_DEPRECATED},
     {"BWP", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"BYB", UCURR_COMMON|UCURR_DEPRECATED},
-    {"BYR", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"BYN", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"BYR", UCURR_COMMON|UCURR_DEPRECATED},
     {"BZD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"CAD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"CDF", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1739,6 +1797,7 @@ static const struct CurrencyList {
     {"CLE", UCURR_COMMON|UCURR_DEPRECATED},
     {"CLF", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"CLP", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"CNH", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"CNX", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"CNY", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"COP", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1761,7 +1820,7 @@ static const struct CurrencyList {
     {"ECV", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"EEK", UCURR_COMMON|UCURR_DEPRECATED},
     {"EGP", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"EQE", UCURR_COMMON|UCURR_DEPRECATED},
+    {"EQE", UCURR_COMMON|UCURR_DEPRECATED}, // questionable, remove?
     {"ERN", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"ESA", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"ESB", UCURR_UNCOMMON|UCURR_DEPRECATED},
@@ -1785,7 +1844,7 @@ static const struct CurrencyList {
     {"GRD", UCURR_COMMON|UCURR_DEPRECATED},
     {"GTQ", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"GWE", UCURR_COMMON|UCURR_DEPRECATED},
-    {"GWP", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"GWP", UCURR_COMMON|UCURR_DEPRECATED},
     {"GYD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"HKD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"HNL", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1823,13 +1882,13 @@ static const struct CurrencyList {
     {"LKR", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"LRD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"LSL", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"LSM", UCURR_COMMON|UCURR_DEPRECATED},
-    {"LTL", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"LSM", UCURR_COMMON|UCURR_DEPRECATED}, // questionable, remove?
+    {"LTL", UCURR_COMMON|UCURR_DEPRECATED},
     {"LTT", UCURR_COMMON|UCURR_DEPRECATED},
     {"LUC", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"LUF", UCURR_COMMON|UCURR_DEPRECATED},
     {"LUL", UCURR_UNCOMMON|UCURR_DEPRECATED},
-    {"LVL", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"LVL", UCURR_COMMON|UCURR_DEPRECATED},
     {"LVR", UCURR_COMMON|UCURR_DEPRECATED},
     {"LYD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MAD", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1845,18 +1904,19 @@ static const struct CurrencyList {
     {"MMK", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MNT", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MOP", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"MRO", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"MRO", UCURR_COMMON|UCURR_DEPRECATED},
+    {"MRU", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MTL", UCURR_COMMON|UCURR_DEPRECATED},
     {"MTP", UCURR_COMMON|UCURR_DEPRECATED},
     {"MUR", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"MVP", UCURR_COMMON|UCURR_DEPRECATED},
+    {"MVP", UCURR_COMMON|UCURR_DEPRECATED}, // questionable, remove?
     {"MVR", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MWK", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MXN", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"MXP", UCURR_COMMON|UCURR_DEPRECATED},
     {"MXV", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"MYR", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"MZE", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"MZE", UCURR_COMMON|UCURR_DEPRECATED},
     {"MZM", UCURR_COMMON|UCURR_DEPRECATED},
     {"MZN", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"NAD", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1897,15 +1957,16 @@ static const struct CurrencyList {
     {"SGD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SHP", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SIT", UCURR_COMMON|UCURR_DEPRECATED},
-    {"SKK", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"SKK", UCURR_COMMON|UCURR_DEPRECATED},
     {"SLL", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SOS", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SRD", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SRG", UCURR_COMMON|UCURR_DEPRECATED},
     {"SSP", UCURR_COMMON|UCURR_NON_DEPRECATED},
-    {"STD", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"STD", UCURR_COMMON|UCURR_DEPRECATED},
+    {"STN", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SUR", UCURR_COMMON|UCURR_DEPRECATED},
-    {"SVC", UCURR_COMMON|UCURR_NON_DEPRECATED},
+    {"SVC", UCURR_COMMON|UCURR_DEPRECATED},
     {"SYP", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"SZL", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"THB", UCURR_COMMON|UCURR_NON_DEPRECATED},
@@ -1954,7 +2015,7 @@ static const struct CurrencyList {
     {"XPD", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"XPF", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"XPT", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
-    {"XRE", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
+    {"XRE", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"XSU", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"XTS", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
     {"XUA", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
@@ -1965,15 +2026,15 @@ static const struct CurrencyList {
     {"YUM", UCURR_COMMON|UCURR_DEPRECATED},
     {"YUN", UCURR_COMMON|UCURR_DEPRECATED},
     {"YUR", UCURR_COMMON|UCURR_DEPRECATED},
-    {"ZAL", UCURR_UNCOMMON|UCURR_NON_DEPRECATED},
+    {"ZAL", UCURR_UNCOMMON|UCURR_DEPRECATED},
     {"ZAR", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"ZMK", UCURR_COMMON|UCURR_DEPRECATED},
     {"ZMW", UCURR_COMMON|UCURR_NON_DEPRECATED},
     {"ZRN", UCURR_COMMON|UCURR_DEPRECATED},
     {"ZRZ", UCURR_COMMON|UCURR_DEPRECATED},
+    {"ZWD", UCURR_COMMON|UCURR_DEPRECATED},
     {"ZWL", UCURR_COMMON|UCURR_DEPRECATED},
     {"ZWR", UCURR_COMMON|UCURR_DEPRECATED},
-    {"ZWD", UCURR_COMMON|UCURR_DEPRECATED},
     { NULL, 0 } // Leave here to denote the end of the list.
 };
 
@@ -2144,16 +2205,20 @@ static void U_CALLCONV initIsoCodes(UErrorCode &status) {
 }
 
 static void populateCurrSymbolsEquiv(icu::Hashtable *hash, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    int32_t length = UPRV_LENGTHOF(EQUIV_CURRENCY_SYMBOLS);
-    for (int32_t i = 0; i < length; ++i) {
-        icu::UnicodeString lhs(EQUIV_CURRENCY_SYMBOLS[i][0], -1, US_INV);
-        icu::UnicodeString rhs(EQUIV_CURRENCY_SYMBOLS[i][1], -1, US_INV);
-        makeEquivalent(lhs.unescape(), rhs.unescape(), hash, status);
-        if (U_FAILURE(status)) {
-            return;
+    if (U_FAILURE(status)) { return; }
+    for (auto& entry : unisets::kCurrencyEntries) {
+        UnicodeString exemplar(entry.exemplar);
+        const UnicodeSet* set = unisets::get(entry.key);
+        if (set == nullptr) { return; }
+        UnicodeSetIterator it(*set);
+        while (it.next()) {
+            UnicodeString value = it.getString();
+            if (value == exemplar) {
+                // No need to mark the exemplar character as an equivalent
+                continue;
+            }
+            makeEquivalent(exemplar, value, hash, status);
+            if (U_FAILURE(status)) { return; }
         }
     }
 }
diff --git a/deps/icu-small/source/common/ucurrimp.h b/deps/icu-small/source/common/ucurrimp.h
index 6e468fd4c94299..6d9588295df7bb 100644
--- a/deps/icu-small/source/common/ucurrimp.h
+++ b/deps/icu-small/source/common/ucurrimp.h
@@ -13,6 +13,7 @@
 #include "unicode/utypes.h"
 #include "unicode/unistr.h"
 #include "unicode/parsepos.h"
+#include "unicode/uniset.h"
 
 /**
  * Internal method.  Given a currency ISO code and a locale, return
@@ -36,6 +37,8 @@ uprv_getStaticCurrencyName(const UChar* iso, const char* loc,
  * match, then the display name is preferred, unless it's length
  * is less than 3.
  *
+ * The parameters must not be NULL.
+ *
  * @param locale the locale of the display names to match
  * @param text the text to parse
  * @param pos input-output position; on input, the position within
@@ -43,6 +46,8 @@ uprv_getStaticCurrencyName(const UChar* iso, const char* loc,
  * on output, the position after the last matched character. If
  * the parse fails, the position in unchanged upon output.
  * @param type currency type to parse against, LONG_NAME only or not
+ * @param partialMatchLen The length of the longest matching prefix;
+ * this may be nonzero even if no full currency was matched.
  * @return the ISO 4217 code, as a string, of the best match, or
  * null if there is no match
  *
@@ -53,9 +58,21 @@ uprv_parseCurrency(const char* locale,
                    const icu::UnicodeString& text,
                    icu::ParsePosition& pos,
                    int8_t type,
+                   int32_t* partialMatchLen,
                    UChar* result,
                    UErrorCode& ec);
 
+/**
+ * Puts all possible first-characters of a currency into the
+ * specified UnicodeSet.
+ *
+ * @param locale the locale of the display names of interest
+ * @param result the UnicodeSet to which to add the starting characters
+ */
+void uprv_currencyLeads(const char* locale, icu::UnicodeSet& result, UErrorCode& ec);
+
+
+
 #endif /* #ifndef _UCURR_IMP_H_ */
 
 //eof
diff --git a/deps/icu-small/source/common/unicode/brkiter.h b/deps/icu-small/source/common/unicode/brkiter.h
index 607f3ec625ab1f..5faeedfa93ecb8 100644
--- a/deps/icu-small/source/common/unicode/brkiter.h
+++ b/deps/icu-small/source/common/unicode/brkiter.h
@@ -638,7 +638,7 @@ class U_COMMON_API BreakIterator : public UObject {
 
 private:
 
-    /** @internal */
+    /** @internal (private) */
     char actualLocale[ULOC_FULLNAME_CAPACITY];
     char validLocale[ULOC_FULLNAME_CAPACITY];
 };
diff --git a/deps/icu-small/source/common/unicode/bytestriebuilder.h b/deps/icu-small/source/common/unicode/bytestriebuilder.h
index 7a806bb7f02096..b164e3bbd685f7 100644
--- a/deps/icu-small/source/common/unicode/bytestriebuilder.h
+++ b/deps/icu-small/source/common/unicode/bytestriebuilder.h
@@ -143,7 +143,7 @@ class U_COMMON_API BytesTrieBuilder : public StringTrieBuilder {
     virtual int32_t getMaxLinearMatchLength() const { return BytesTrie::kMaxLinearMatchLength; }
 
     /**
-     * @internal
+     * @internal (private)
      */
     class BTLinearMatchNode : public LinearMatchNode {
     public:
diff --git a/deps/icu-small/source/common/unicode/caniter.h b/deps/icu-small/source/common/unicode/caniter.h
index 543341f42c5fe2..b47e35da07bb7f 100644
--- a/deps/icu-small/source/common/unicode/caniter.h
+++ b/deps/icu-small/source/common/unicode/caniter.h
@@ -153,13 +153,13 @@ class U_COMMON_API CanonicalIterator U_FINAL : public UObject {
 
     /**
      * Copy constructor. Private for now.
-     * @internal
+     * @internal (private)
      */
     CanonicalIterator(const CanonicalIterator& other);
 
     /**
      * Assignment operator. Private for now.
-     * @internal
+     * @internal (private)
      */
     CanonicalIterator& operator=(const CanonicalIterator& other);
 
diff --git a/deps/icu-small/source/common/unicode/docmain.h b/deps/icu-small/source/common/unicode/docmain.h
index 3e645aee4a87fb..91e5ae3fa2e2e6 100644
--- a/deps/icu-small/source/common/unicode/docmain.h
+++ b/deps/icu-small/source/common/unicode/docmain.h
@@ -139,7 +139,7 @@
  *   </tr>
  *   <tr>
  *     <td>Number Formatting</td>
- *     <td>unum.h</td>
+ *     <td>unumberformatter.h, unum.h</td>
  *     <td>icu::number::NumberFormatter (ICU 60+) or icu::NumberFormat (older versions)</td>
  *   </tr>
  *   <tr>
diff --git a/deps/icu-small/source/common/unicode/edits.h b/deps/icu-small/source/common/unicode/edits.h
index 5a72574c140db6..f767a8d3b494c3 100644
--- a/deps/icu-small/source/common/unicode/edits.h
+++ b/deps/icu-small/source/common/unicode/edits.h
@@ -17,10 +17,57 @@
 
 U_NAMESPACE_BEGIN
 
+class UnicodeString;
+
 /**
- * Records lengths of string edits but not replacement text.
- * Supports replacements, insertions, deletions in linear progression.
- * Does not support moving/reordering of text.
+ * Records lengths of string edits but not replacement text. Supports replacements, insertions, deletions
+ * in linear progression. Does not support moving/reordering of text.
+ *
+ * There are two types of edits: <em>change edits</em> and <em>no-change edits</em>. Add edits to
+ * instances of this class using {@link #addReplace(int, int)} (for change edits) and
+ * {@link #addUnchanged(int)} (for no-change edits). Change edits are retained with full granularity,
+ * whereas adjacent no-change edits are always merged together. In no-change edits, there is a one-to-one
+ * mapping between code points in the source and destination strings.
+ *
+ * After all edits have been added, instances of this class should be considered immutable, and an
+ * {@link Edits::Iterator} can be used for queries.
+ *
+ * There are four flavors of Edits::Iterator:
+ *
+ * <ul>
+ * <li>{@link #getFineIterator()} retains full granularity of change edits.
+ * <li>{@link #getFineChangesIterator()} retains full granularity of change edits, and when calling
+ * next() on the iterator, skips over no-change edits (unchanged regions).
+ * <li>{@link #getCoarseIterator()} treats adjacent change edits as a single edit. (Adjacent no-change
+ * edits are automatically merged during the construction phase.)
+ * <li>{@link #getCoarseChangesIterator()} treats adjacent change edits as a single edit, and when
+ * calling next() on the iterator, skips over no-change edits (unchanged regions).
+ * </ul>
+ *
+ * For example, consider the string "abcßDeF", which case-folds to "abcssdef". This string has the
+ * following fine edits:
+ * <ul>
+ * <li>abc ⇨ abc (no-change)
+ * <li>ß ⇨ ss (change)
+ * <li>D ⇨ d (change)
+ * <li>e ⇨ e (no-change)
+ * <li>F ⇨ f (change)
+ * </ul>
+ * and the following coarse edits (note how adjacent change edits get merged together):
+ * <ul>
+ * <li>abc ⇨ abc (no-change)
+ * <li>ßD ⇨ ssd (change)
+ * <li>e ⇨ e (no-change)
+ * <li>F ⇨ f (change)
+ * </ul>
+ *
+ * The "fine changes" and "coarse changes" iterators will step through only the change edits when their
+ * {@link Edits::Iterator#next()} methods are called. They are identical to the non-change iterators when
+ * their {@link Edits::Iterator#findSourceIndex(int)} or {@link Edits::Iterator#findDestinationIndex(int)}
+ * methods are used to walk through the string.
+ *
+ * For examples of how to use this class, see the test <code>TestCaseMapEditsIteratorDocs</code> in
+ * UCharacterCaseTest.java.
  *
  * An Edits object tracks a separate UErrorCode, but ICU string transformation functions
  * (e.g., case mapping functions) merge any such errors into their API's UErrorCode.
@@ -91,13 +138,13 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
     void reset() U_NOEXCEPT;
 
     /**
-     * Adds a record for an unchanged segment of text.
+     * Adds a no-change edit: a record for an unchanged segment of text.
      * Normally called from inside ICU string transformation functions, not user code.
      * @stable ICU 59
      */
     void addUnchanged(int32_t unchangedLength);
     /**
-     * Adds a record for a text replacement/insertion/deletion.
+     * Adds a change edit: a record for a text replacement/insertion/deletion.
      * Normally called from inside ICU string transformation functions, not user code.
      * @stable ICU 59
      */
@@ -136,6 +183,18 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
 
     /**
      * Access to the list of edits.
+     *
+     * At any moment in time, an instance of this class points to a single edit: a "window" into a span
+     * of the source string and the corresponding span of the destination string. The source string span
+     * starts at {@link #sourceIndex()} and runs for {@link #oldLength()} chars; the destination string
+     * span starts at {@link #destinationIndex()} and runs for {@link #newLength()} chars.
+     *
+     * The iterator can be moved between edits using the {@link #next()}, {@link #findSourceIndex(int)},
+     * and {@link #findDestinationIndex(int)} methods. Calling any of these methods mutates the iterator
+     * to make it point to the corresponding edit.
+     *
+     * For more information, see the documentation for {@link Edits}.
+     *
      * @see getCoarseIterator
      * @see getFineIterator
      * @stable ICU 59
@@ -162,7 +221,7 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
         Iterator &operator=(const Iterator &other) = default;
 
         /**
-         * Advances to the next edit.
+         * Advances the iterator to the next edit.
          * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
          *                  or else the function returns immediately. Check for U_FAILURE()
          *                  on output or use with function chaining. (See User Guide for details.)
@@ -172,9 +231,9 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
         UBool next(UErrorCode &errorCode) { return next(onlyChanges_, errorCode); }
 
         /**
-         * Finds the edit that contains the source index.
-         * The source index may be found in a non-change
-         * even if normal iteration would skip non-changes.
+         * Moves the iterator to the edit that contains the source index.
+         * The source index may be found in a no-change edit
+         * even if normal iteration would skip no-change edits.
          * Normal iteration can continue from a found edit.
          *
          * The iterator state before this search logically does not matter.
@@ -196,9 +255,9 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
 
 #ifndef U_HIDE_DRAFT_API
         /**
-         * Finds the edit that contains the destination index.
-         * The destination index may be found in a non-change
-         * even if normal iteration would skip non-changes.
+         * Moves the iterator to the edit that contains the destination index.
+         * The destination index may be found in a no-change edit
+         * even if normal iteration would skip no-change edits.
          * Normal iteration can continue from a found edit.
          *
          * The iterator state before this search logically does not matter.
@@ -219,7 +278,7 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
         }
 
         /**
-         * Returns the destination index corresponding to the given source index.
+         * Computes the destination index corresponding to the given source index.
          * If the source index is inside a change edit (not at its start),
          * then the destination index at the end of that edit is returned,
          * since there is no information about index mapping inside a change edit.
@@ -243,7 +302,7 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
         int32_t destinationIndexFromSourceIndex(int32_t i, UErrorCode &errorCode);
 
         /**
-         * Returns the source index corresponding to the given destination index.
+         * Computes the source index corresponding to the given destination index.
          * If the destination index is inside a change edit (not at its start),
          * then the source index at the end of that edit is returned,
          * since there is no information about index mapping inside a change edit.
@@ -268,17 +327,27 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
 #endif  // U_HIDE_DRAFT_API
 
         /**
+         * Returns whether the edit currently represented by the iterator is a change edit.
+         *
          * @return TRUE if this edit replaces oldLength() units with newLength() different ones.
          *         FALSE if oldLength units remain unchanged.
          * @stable ICU 59
          */
         UBool hasChange() const { return changed; }
+
         /**
+         * The length of the current span in the source string, which starts at {@link #sourceIndex}.
+         *
          * @return the number of units in the original string which are replaced or remain unchanged.
          * @stable ICU 59
          */
         int32_t oldLength() const { return oldLength_; }
+
         /**
+         * The length of the current span in the destination string, which starts at
+         * {@link #destinationIndex}, or in the replacement string, which starts at
+         * {@link #replacementIndex}.
+         *
          * @return the number of units in the modified string, if hasChange() is TRUE.
          *         Same as oldLength if hasChange() is FALSE.
          * @stable ICU 59
@@ -286,22 +355,52 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
         int32_t newLength() const { return newLength_; }
 
         /**
+         * The start index of the current span in the source string; the span has length
+         * {@link #oldLength}.
+         *
          * @return the current index into the source string
          * @stable ICU 59
          */
         int32_t sourceIndex() const { return srcIndex; }
+
         /**
+         * The start index of the current span in the replacement string; the span has length
+         * {@link #newLength}. Well-defined only if the current edit is a change edit.
+         * <p>
+         * The <em>replacement string</em> is the concatenation of all substrings of the destination
+         * string corresponding to change edits.
+         * <p>
+         * This method is intended to be used together with operations that write only replacement
+         * characters (e.g., {@link CaseMap#omitUnchangedText()}). The source string can then be modified
+         * in-place.
+         *
          * @return the current index into the replacement-characters-only string,
          *         not counting unchanged spans
          * @stable ICU 59
          */
-        int32_t replacementIndex() const { return replIndex; }
+        int32_t replacementIndex() const {
+            // TODO: Throw an exception if we aren't in a change edit?
+            return replIndex;
+        }
+
         /**
+         * The start index of the current span in the destination string; the span has length
+         * {@link #newLength}.
+         *
          * @return the current index into the full destination string
          * @stable ICU 59
          */
         int32_t destinationIndex() const { return destIndex; }
 
+#ifndef U_HIDE_INTERNAL_API
+        /**
+         * A string representation of the current edit represented by the iterator for debugging. You
+         * should not depend on the contents of the return string.
+         * @internal
+         */
+        UnicodeString& toString(UnicodeString& appendTo) const;
+#endif  // U_HIDE_INTERNAL_API
+
     private:
         friend class Edits;
 
@@ -330,8 +429,10 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
     };
 
     /**
-     * Returns an Iterator for coarse-grained changes for simple string updates.
-     * Skips non-changes.
+     * Returns an Iterator for coarse-grained change edits
+     * (adjacent change edits are treated as one).
+     * Can be used to perform simple string updates.
+     * Skips no-change edits.
      * @return an Iterator that merges adjacent changes.
      * @stable ICU 59
      */
@@ -340,7 +441,10 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
     }
 
     /**
-     * Returns an Iterator for coarse-grained changes and non-changes for simple string updates.
+     * Returns an Iterator for coarse-grained change and no-change edits
+     * (adjacent change edits are treated as one).
+     * Can be used to perform simple string updates.
+     * Adjacent change edits are treated as one edit.
      * @return an Iterator that merges adjacent changes.
      * @stable ICU 59
      */
@@ -349,8 +453,10 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
     }
 
     /**
-     * Returns an Iterator for fine-grained changes for modifying styled text.
-     * Skips non-changes.
+     * Returns an Iterator for fine-grained change edits
+     * (full granularity of change edits is retained).
+     * Can be used for modifying styled text.
+     * Skips no-change edits.
      * @return an Iterator that separates adjacent changes.
      * @stable ICU 59
      */
@@ -359,7 +465,9 @@ class U_COMMON_API Edits U_FINAL : public UMemory {
     }
 
     /**
-     * Returns an Iterator for fine-grained changes and non-changes for modifying styled text.
+     * Returns an Iterator for fine-grained change and no-change edits
+     * (full granularity of change edits is retained).
+     * Can be used for modifying styled text.
      * @return an Iterator that separates adjacent changes.
      * @stable ICU 59
      */
diff --git a/deps/icu-small/source/common/unicode/platform.h b/deps/icu-small/source/common/unicode/platform.h
index a3f8d32f89d2cd..d9636580c309b5 100644
--- a/deps/icu-small/source/common/unicode/platform.h
+++ b/deps/icu-small/source/common/unicode/platform.h
@@ -196,20 +196,6 @@
 #   define U_PLATFORM U_PF_UNKNOWN
 #endif
 
-/**
- * \def UPRV_INCOMPLETE_CPP11_SUPPORT
- * This switch turns off ICU 60 NumberFormatter code.
- * By default, this switch is enabled on AIX and z/OS,
- * which have poor C++11 support.
- *
- * NOTE: This switch is intended to be temporary; see #13393.
- *
- * @internal
- */
-#ifndef UPRV_INCOMPLETE_CPP11_SUPPORT
-#   define UPRV_INCOMPLETE_CPP11_SUPPORT (U_PLATFORM == U_PF_AIX || U_PLATFORM == U_PF_OS390 || U_PLATFORM == U_PF_SOLARIS )
-#endif
-
 /**
  * \def CYGWINMSVC
  * Defined if this is Windows with Cygwin, but using MSVC rather than gcc.
diff --git a/deps/icu-small/source/common/unicode/rbbi.h b/deps/icu-small/source/common/unicode/rbbi.h
index 0c41d69d235ccb..e9b82cd520736b 100644
--- a/deps/icu-small/source/common/unicode/rbbi.h
+++ b/deps/icu-small/source/common/unicode/rbbi.h
@@ -55,7 +55,7 @@ class U_COMMON_API RuleBasedBreakIterator /*U_FINAL*/ : public BreakIterator {
 private:
     /**
      * The UText through which this BreakIterator accesses the text
-     * @internal
+     * @internal (private)
      */
     UText  fText;
 
@@ -70,13 +70,6 @@ class U_COMMON_API RuleBasedBreakIterator /*U_FINAL*/ : public BreakIterator {
     RBBIDataWrapper    *fData;
 private:
 
-    /**
-     *  The iteration state - current position, rule status for the current position,
-     *                        and whether the iterator ran off the end, yielding UBRK_DONE.
-     *                        Current position is pinned to be 0 < position <= text.length.
-     *                        Current position is always set to a boundary.
-     *  @internal
-    */
     /**
       * The current  position of the iterator. Pinned, 0 < fPosition <= text.length.
       * Never has the value UBRK_DONE (-1).
@@ -628,25 +621,26 @@ class U_COMMON_API RuleBasedBreakIterator /*U_FINAL*/ : public BreakIterator {
     /**
      * Dumps caches and performs other actions associated with a complete change
      * in text or iteration position.
-     * @internal
+     * @internal (private)
      */
     void reset(void);
 
     /**
       * Common initialization function, used by constructors and bufferClone.
-      * @internal
+      * @internal (private)
       */
     void init(UErrorCode &status);
 
     /**
-     * Iterate backwards from an arbitrary position in the input text using the Safe Reverse rules.
+     * Iterate backwards from an arbitrary position in the input text using the
+     * synthesized Safe Reverse rules.
      * This locates a "Safe Position" from which the forward break rules
      * will operate correctly. A Safe Position is not necessarily a boundary itself.
      *
      * @param fromPosition the position in the input text to begin the iteration.
-     * @internal
+     * @internal (private)
      */
-    int32_t handlePrevious(int32_t fromPosition);
+    int32_t handleSafePrevious(int32_t fromPosition);
 
     /**
      * Find a rule-based boundary by running the state machine.
@@ -658,7 +652,7 @@ class U_COMMON_API RuleBasedBreakIterator /*U_FINAL*/ : public BreakIterator {
      *                         If > 0, the segment will be further subdivided
      *    fRuleStatusIndex     Info from the state table indicating which rules caused the boundary.
      *
-     * @internal
+     * @internal (private)
      */
     int32_t handleNext();
 
@@ -667,7 +661,7 @@ class U_COMMON_API RuleBasedBreakIterator /*U_FINAL*/ : public BreakIterator {
      * This function returns the appropriate LanguageBreakEngine for a
      * given character c.
      * @param c         A character in the dictionary set
-     * @internal
+     * @internal (private)
      */
     const LanguageBreakEngine *getLanguageBreakEngine(UChar32 c);
 
diff --git a/deps/icu-small/source/common/unicode/uchar.h b/deps/icu-small/source/common/unicode/uchar.h
index 4b72ecfc26bf9a..6d31083e66ee0d 100644
--- a/deps/icu-small/source/common/unicode/uchar.h
+++ b/deps/icu-small/source/common/unicode/uchar.h
@@ -42,7 +42,7 @@ U_CDECL_BEGIN
  * @see u_getUnicodeVersion
  * @stable ICU 2.0
  */
-#define U_UNICODE_VERSION "10.0"
+#define U_UNICODE_VERSION "11.0"
 
 /**
  * \file
@@ -446,6 +446,13 @@ typedef enum UProperty {
      * @stable ICU 60
      */
     UCHAR_PREPENDED_CONCATENATION_MARK=63,
+    /**
+     * Binary property Extended_Pictographic.
+     * See http://www.unicode.org/reports/tr51/#Emoji_Properties
+     *
+     * @stable ICU 62
+     */
+    UCHAR_EXTENDED_PICTOGRAPHIC=64,
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the last constant for binary Unicode properties.
@@ -1683,6 +1690,31 @@ enum UBlockCode {
     /** @stable ICU 60 */
     UBLOCK_ZANABAZAR_SQUARE = 280, /*[11A00]*/
 
+    // New blocks in Unicode 11.0
+
+    /** @stable ICU 62 */
+    UBLOCK_CHESS_SYMBOLS = 281, /*[1FA00]*/
+    /** @stable ICU 62 */
+    UBLOCK_DOGRA = 282, /*[11800]*/
+    /** @stable ICU 62 */
+    UBLOCK_GEORGIAN_EXTENDED = 283, /*[1C90]*/
+    /** @stable ICU 62 */
+    UBLOCK_GUNJALA_GONDI = 284, /*[11D60]*/
+    /** @stable ICU 62 */
+    UBLOCK_HANIFI_ROHINGYA = 285, /*[10D00]*/
+    /** @stable ICU 62 */
+    UBLOCK_INDIC_SIYAQ_NUMBERS = 286, /*[1EC70]*/
+    /** @stable ICU 62 */
+    UBLOCK_MAKASAR = 287, /*[11EE0]*/
+    /** @stable ICU 62 */
+    UBLOCK_MAYAN_NUMERALS = 288, /*[1D2E0]*/
+    /** @stable ICU 62 */
+    UBLOCK_MEDEFAIDRIN = 289, /*[16E40]*/
+    /** @stable ICU 62 */
+    UBLOCK_OLD_SOGDIAN = 290, /*[10F00]*/
+    /** @stable ICU 62 */
+    UBLOCK_SOGDIAN = 291, /*[10F30]*/
+
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal UBlockCode value.
@@ -1690,7 +1722,7 @@ enum UBlockCode {
      *
      * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
      */
-    UBLOCK_COUNT = 281,
+    UBLOCK_COUNT = 292,
 #endif  // U_HIDE_DEPRECATED_API
 
     /** @stable ICU 2.0 */
@@ -1979,6 +2011,9 @@ typedef enum UJoiningGroup {
     U_JG_MALAYALAM_SSA,  /**< @stable ICU 60 */
     U_JG_MALAYALAM_TTA,  /**< @stable ICU 60 */
 
+    U_JG_HANIFI_ROHINGYA_KINNA_YA,  /**< @stable ICU 62 */
+    U_JG_HANIFI_ROHINGYA_PA,  /**< @stable ICU 62 */
+
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal UJoiningGroup value.
@@ -2029,6 +2064,7 @@ typedef enum UGraphemeClusterBreak {
     U_GCB_GLUE_AFTER_ZWJ = 16,  /*[GAZ]*/
     /** @stable ICU 58 */
     U_GCB_ZWJ = 17,             /*[ZWJ]*/
+
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal UGraphemeClusterBreak value.
@@ -2090,6 +2126,9 @@ typedef enum UWordBreakValues {
     U_WB_GLUE_AFTER_ZWJ = 20,   /*[GAZ]*/
     /** @stable ICU 58 */
     U_WB_ZWJ = 21,              /*[ZWJ]*/
+    /** @stable ICU 62 */
+    U_WB_WSEGSPACE = 22,        /*[WSEGSPACE]*/
+
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal UWordBreakValues value.
@@ -2097,7 +2136,7 @@ typedef enum UWordBreakValues {
      *
      * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
      */
-    U_WB_COUNT = 22
+    U_WB_COUNT = 23
 #endif  // U_HIDE_DEPRECATED_API
 } UWordBreakValues;
 
diff --git a/deps/icu-small/source/common/unicode/unistr.h b/deps/icu-small/source/common/unicode/unistr.h
index d0b271754b660e..b84f40bd449ced 100644
--- a/deps/icu-small/source/common/unicode/unistr.h
+++ b/deps/icu-small/source/common/unicode/unistr.h
@@ -1892,7 +1892,7 @@ class U_COMMON_API UnicodeString : public Replaceable
   UnicodeString &fastCopyFrom(const UnicodeString &src);
 
   /**
-   * Move assignment operator, might leave src in bogus state.
+   * Move assignment operator; might leave src in bogus state.
    * This string will have the same contents and state that the source string had.
    * The behavior is undefined if *this and src are the same object.
    * @param src source string
@@ -1905,7 +1905,7 @@ class U_COMMON_API UnicodeString : public Replaceable
 
   // do not use #ifndef U_HIDE_DRAFT_API for moveFrom, needed by non-draft API
   /**
-   * Move assignment, might leave src in bogus state.
+   * Move assignment; might leave src in bogus state.
    * This string will have the same contents and state that the source string had.
    * The behavior is undefined if *this and src are the same object.
    *
@@ -3314,7 +3314,7 @@ class U_COMMON_API UnicodeString : public Replaceable
   UnicodeString(const UnicodeString& that);
 
   /**
-   * Move constructor, might leave src in bogus state.
+   * Move constructor; might leave src in bogus state.
    * This string will have the same contents and state that the source string had.
    * @param src source string
    * @stable ICU 56
diff --git a/deps/icu-small/source/common/unicode/urename.h b/deps/icu-small/source/common/unicode/urename.h
index d8ab85091f5721..4175e527f404a7 100644
--- a/deps/icu-small/source/common/unicode/urename.h
+++ b/deps/icu-small/source/common/unicode/urename.h
@@ -613,6 +613,7 @@
 #define ucnv_createConverterFromPackage U_ICU_ENTRY_POINT_RENAME(ucnv_createConverterFromPackage)
 #define ucnv_createConverterFromSharedData U_ICU_ENTRY_POINT_RENAME(ucnv_createConverterFromSharedData)
 #define ucnv_detectUnicodeSignature U_ICU_ENTRY_POINT_RENAME(ucnv_detectUnicodeSignature)
+#define ucnv_enableCleanup U_ICU_ENTRY_POINT_RENAME(ucnv_enableCleanup)
 #define ucnv_extContinueMatchFromU U_ICU_ENTRY_POINT_RENAME(ucnv_extContinueMatchFromU)
 #define ucnv_extContinueMatchToU U_ICU_ENTRY_POINT_RENAME(ucnv_extContinueMatchToU)
 #define ucnv_extGetUnicodeSet U_ICU_ENTRY_POINT_RENAME(ucnv_extGetUnicodeSet)
@@ -1170,6 +1171,16 @@
 #define unum_setSymbol U_ICU_ENTRY_POINT_RENAME(unum_setSymbol)
 #define unum_setTextAttribute U_ICU_ENTRY_POINT_RENAME(unum_setTextAttribute)
 #define unum_toPattern U_ICU_ENTRY_POINT_RENAME(unum_toPattern)
+#define unumf_close U_ICU_ENTRY_POINT_RENAME(unumf_close)
+#define unumf_closeResult U_ICU_ENTRY_POINT_RENAME(unumf_closeResult)
+#define unumf_formatDecimal U_ICU_ENTRY_POINT_RENAME(unumf_formatDecimal)
+#define unumf_formatDouble U_ICU_ENTRY_POINT_RENAME(unumf_formatDouble)
+#define unumf_formatInt U_ICU_ENTRY_POINT_RENAME(unumf_formatInt)
+#define unumf_openForSkeletonAndLocale U_ICU_ENTRY_POINT_RENAME(unumf_openForSkeletonAndLocale)
+#define unumf_openResult U_ICU_ENTRY_POINT_RENAME(unumf_openResult)
+#define unumf_resultGetAllFieldPositions U_ICU_ENTRY_POINT_RENAME(unumf_resultGetAllFieldPositions)
+#define unumf_resultNextFieldPosition U_ICU_ENTRY_POINT_RENAME(unumf_resultNextFieldPosition)
+#define unumf_resultToString U_ICU_ENTRY_POINT_RENAME(unumf_resultToString)
 #define unumsys_close U_ICU_ENTRY_POINT_RENAME(unumsys_close)
 #define unumsys_getDescription U_ICU_ENTRY_POINT_RENAME(unumsys_getDescription)
 #define unumsys_getName U_ICU_ENTRY_POINT_RENAME(unumsys_getName)
@@ -1209,6 +1220,7 @@
 #define uplug_setPlugNoUnload U_ICU_ENTRY_POINT_RENAME(uplug_setPlugNoUnload)
 #define uprops_getSource U_ICU_ENTRY_POINT_RENAME(uprops_getSource)
 #define upropsvec_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(upropsvec_addPropertyStarts)
+#define uprv_add32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_add32_overflow)
 #define uprv_aestrncpy U_ICU_ENTRY_POINT_RENAME(uprv_aestrncpy)
 #define uprv_asciiFromEbcdic U_ICU_ENTRY_POINT_RENAME(uprv_asciiFromEbcdic)
 #define uprv_asciitolower U_ICU_ENTRY_POINT_RENAME(uprv_asciitolower)
@@ -1343,6 +1355,7 @@
 #define uprv_maximumPtr U_ICU_ENTRY_POINT_RENAME(uprv_maximumPtr)
 #define uprv_min U_ICU_ENTRY_POINT_RENAME(uprv_min)
 #define uprv_modf U_ICU_ENTRY_POINT_RENAME(uprv_modf)
+#define uprv_mul32_overflow U_ICU_ENTRY_POINT_RENAME(uprv_mul32_overflow)
 #define uprv_parseCurrency U_ICU_ENTRY_POINT_RENAME(uprv_parseCurrency)
 #define uprv_pathIsAbsolute U_ICU_ENTRY_POINT_RENAME(uprv_pathIsAbsolute)
 #define uprv_pow U_ICU_ENTRY_POINT_RENAME(uprv_pow)
diff --git a/deps/icu-small/source/common/unicode/uscript.h b/deps/icu-small/source/common/unicode/uscript.h
index 0befa1cd422c20..faf9edf8ae2694 100644
--- a/deps/icu-small/source/common/unicode/uscript.h
+++ b/deps/icu-small/source/common/unicode/uscript.h
@@ -451,6 +451,21 @@ typedef enum UScriptCode {
       /** @stable ICU 60 */
       USCRIPT_ZANABAZAR_SQUARE              = 177,/* Zanb */
 
+      /** @stable ICU 62 */
+      USCRIPT_DOGRA                         = 178,/* Dogr */
+      /** @stable ICU 62 */
+      USCRIPT_GUNJALA_GONDI                 = 179,/* Gong */
+      /** @stable ICU 62 */
+      USCRIPT_MAKASAR                       = 180,/* Maka */
+      /** @stable ICU 62 */
+      USCRIPT_MEDEFAIDRIN                   = 181,/* Medf */
+      /** @stable ICU 62 */
+      USCRIPT_HANIFI_ROHINGYA               = 182,/* Rohg */
+      /** @stable ICU 62 */
+      USCRIPT_SOGDIAN                       = 183,/* Sogd */
+      /** @stable ICU 62 */
+      USCRIPT_OLD_SOGDIAN                   = 184,/* Sogo */
+
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal UScriptCode value.
@@ -458,7 +473,7 @@ typedef enum UScriptCode {
      *
      * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
      */
-    USCRIPT_CODE_LIMIT    = 178
+    USCRIPT_CODE_LIMIT    = 185
 #endif  // U_HIDE_DEPRECATED_API
 } UScriptCode;
 
diff --git a/deps/icu-small/source/common/unicode/utypes.h b/deps/icu-small/source/common/unicode/utypes.h
index b6cf4965112a16..f43056b6f2fd10 100644
--- a/deps/icu-small/source/common/unicode/utypes.h
+++ b/deps/icu-small/source/common/unicode/utypes.h
@@ -542,12 +542,15 @@ typedef enum UErrorCode {
 #ifndef U_HIDE_DRAFT_API
     U_NUMBER_ARG_OUTOFBOUNDS_ERROR,   /**< The argument to a NumberFormatter helper method was out of bounds; the bounds are usually 0 to 999. @draft ICU 61 */
 #endif  // U_HIDE_DRAFT_API
+#ifndef U_HIDE_DRAFT_API
+    U_NUMBER_SKELETON_SYNTAX_ERROR,   /**< The number skeleton passed to C++ NumberFormatter or C UNumberFormatter was invalid or contained a syntax error. @draft ICU 62 */
+#endif  // U_HIDE_DRAFT_API
 #ifndef U_HIDE_DEPRECATED_API
     /**
      * One more than the highest normal formatting API error code.
      * @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
      */
-    U_FMT_PARSE_ERROR_LIMIT = 0x10113,
+    U_FMT_PARSE_ERROR_LIMIT = 0x10114,
 #endif  // U_HIDE_DEPRECATED_API
 
     /*
diff --git a/deps/icu-small/source/common/unicode/uvernum.h b/deps/icu-small/source/common/unicode/uvernum.h
index 0427bcb03db4e3..2240661112c1ad 100644
--- a/deps/icu-small/source/common/unicode/uvernum.h
+++ b/deps/icu-small/source/common/unicode/uvernum.h
@@ -58,7 +58,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.4
  */
-#define U_ICU_VERSION_MAJOR_NUM 61
+#define U_ICU_VERSION_MAJOR_NUM 62
 
 /** The current ICU minor version as an integer.
  *  This value will change in the subsequent releases of ICU
@@ -84,7 +84,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.6
  */
-#define U_ICU_VERSION_SUFFIX _61
+#define U_ICU_VERSION_SUFFIX _62
 
 /**
  * \def U_DEF2_ICU_ENTRY_POINT_RENAME
@@ -119,7 +119,7 @@
  *  This value will change in the subsequent releases of ICU
  *  @stable ICU 2.4
  */
-#define U_ICU_VERSION "61.1"
+#define U_ICU_VERSION "62.1"
 
 /**
  * The current ICU library major version number as a string, for library name suffixes.
@@ -132,13 +132,13 @@
  *
  * @stable ICU 2.6
  */
-#define U_ICU_VERSION_SHORT "61"
+#define U_ICU_VERSION_SHORT "62"
 
 #ifndef U_HIDE_INTERNAL_API
 /** Data version in ICU4C.
  * @internal ICU 4.4 Internal Use Only
  **/
-#define U_ICU_DATA_VERSION "61.1"
+#define U_ICU_DATA_VERSION "62.1"
 #endif  /* U_HIDE_INTERNAL_API */
 
 /*===========================================================================
diff --git a/deps/icu-small/source/common/uprops.cpp b/deps/icu-small/source/common/uprops.cpp
index b76896db1b704f..21723b32aa7c8d 100644
--- a/deps/icu-small/source/common/uprops.cpp
+++ b/deps/icu-small/source/common/uprops.cpp
@@ -282,6 +282,7 @@ static const BinaryProperty binProps[UCHAR_BINARY_LIMIT]={
     { 2,                U_MASK(UPROPS_2_EMOJI_COMPONENT), defaultContains },
     { 2,                0, isRegionalIndicator },
     { 1,                U_MASK(UPROPS_PREPENDED_CONCATENATION_MARK), defaultContains },
+    { 2,                U_MASK(UPROPS_2_EXTENDED_PICTOGRAPHIC), defaultContains },
 };
 
 U_CAPI UBool U_EXPORT2
diff --git a/deps/icu-small/source/common/uprops.h b/deps/icu-small/source/common/uprops.h
index 6f67756cd91033..2078384c3e47dd 100644
--- a/deps/icu-small/source/common/uprops.h
+++ b/deps/icu-small/source/common/uprops.h
@@ -196,8 +196,7 @@ enum {
 /*
  * Properties in vector word 2
  * Bits
- * 31..27   http://www.unicode.org/reports/tr51/#Emoji_Properties
- *     26   reserved
+ * 31..26   http://www.unicode.org/reports/tr51/#Emoji_Properties
  * 25..20   Line Break
  * 19..15   Sentence Break
  * 14..10   Word Break
@@ -205,7 +204,8 @@ enum {
  *  4.. 0   Decomposition Type
  */
 enum {
-    UPROPS_2_EMOJI_COMPONENT=27,
+    UPROPS_2_EXTENDED_PICTOGRAPHIC=26,
+    UPROPS_2_EMOJI_COMPONENT,
     UPROPS_2_EMOJI,
     UPROPS_2_EMOJI_PRESENTATION,
     UPROPS_2_EMOJI_MODIFIER,
diff --git a/deps/icu-small/source/common/uscript_props.cpp b/deps/icu-small/source/common/uscript_props.cpp
index 7998c52c7f02c5..bfdb68c7a9c998 100644
--- a/deps/icu-small/source/common/uscript_props.cpp
+++ b/deps/icu-small/source/common/uscript_props.cpp
@@ -71,7 +71,7 @@ const int32_t SCRIPT_PROPS[] = {
     0x0EA5 | RECOMMENDED | LB_LETTERS,  // Laoo
     0x004C | RECOMMENDED | CASED,  // Latn
     0x0D15 | RECOMMENDED,  // Mlym
-    0x1826 | LIMITED_USE,  // Mong
+    0x1826 | EXCLUSION,  // Mong
     0x1000 | RECOMMENDED | LB_LETTERS,  // Mymr
     0x168F | EXCLUSION,  // Ogam
     0x10300 | EXCLUSION,  // Ital
@@ -222,6 +222,13 @@ const int32_t SCRIPT_PROPS[] = {
     0x11D10 | EXCLUSION,  // Gonm
     0x11A5C | EXCLUSION,  // Soyo
     0x11A0B | EXCLUSION,  // Zanb
+    0x1180B | EXCLUSION,  // Dogr
+    0x11D71 | LIMITED_USE,  // Gong
+    0x11EE5 | EXCLUSION,  // Maka
+    0x16E40 | EXCLUSION | CASED,  // Medf
+    0x10D12 | LIMITED_USE | RTL,  // Rohg
+    0x10F42 | EXCLUSION | RTL,  // Sogd
+    0x10F19 | EXCLUSION | RTL,  // Sogo
     // End copy-paste from parsescriptmetadata.py
 };
 
diff --git a/deps/icu-small/source/common/ustr_cnv.cpp b/deps/icu-small/source/common/ustr_cnv.cpp
index 951864f4a6c7db..eb37232c25d50b 100644
--- a/deps/icu-small/source/common/ustr_cnv.cpp
+++ b/deps/icu-small/source/common/ustr_cnv.cpp
@@ -28,6 +28,7 @@
 #include "cmemory.h"
 #include "umutex.h"
 #include "ustr_cnv.h"
+#include "ucnv_bld.h"
 
 /* mutexed access to a shared default converter ----------------------------- */
 
@@ -68,8 +69,8 @@ u_releaseDefaultConverter(UConverter *converter)
         if (converter != NULL) {
             ucnv_reset(converter);
         }
+        ucnv_enableCleanup();
         umtx_lock(NULL);
-
         if(gDefaultConverter == NULL) {
             gDefaultConverter = converter;
             converter = NULL;
diff --git a/deps/icu-small/source/common/util.h b/deps/icu-small/source/common/util.h
index 7af9a32d8ffe53..92cdc9ef69a58a 100644
--- a/deps/icu-small/source/common/util.h
+++ b/deps/icu-small/source/common/util.h
@@ -46,6 +46,13 @@ class U_COMMON_API ICU_Utility /* not : public UObject because all methods are s
                                        int32_t radix = 10,
                                        int32_t minDigits = 1);
 
+    /** Returns a bogus UnicodeString by value. */
+    static inline UnicodeString makeBogusString() {
+        UnicodeString result;
+        result.setToBogus();
+        return result;
+    }
+
     /**
      * Return true if the character is NOT printable ASCII.
      *
diff --git a/deps/icu-small/source/common/utypes.cpp b/deps/icu-small/source/common/utypes.cpp
index 5d6a0504ba682a..7531e465683342 100644
--- a/deps/icu-small/source/common/utypes.cpp
+++ b/deps/icu-small/source/common/utypes.cpp
@@ -126,7 +126,8 @@ _uFmtErrorName[U_FMT_PARSE_ERROR_LIMIT - U_FMT_PARSE_ERROR_START] = {
     "U_DEFAULT_KEYWORD_MISSING",
     "U_DECIMAL_NUMBER_SYNTAX_ERROR",
     "U_FORMAT_INEXACT_ERROR",
-    "U_NUMBER_ARG_OUTOFBOUNDS_ERROR"
+    "U_NUMBER_ARG_OUTOFBOUNDS_ERROR",
+    "U_NUMBER_SKELETON_SYNTAX_ERROR",
 };
 
 static const char * const
diff --git a/deps/icu-small/source/common/wintz.cpp b/deps/icu-small/source/common/wintz.cpp
index c30a5dbc606894..3708925b38f0cd 100644
--- a/deps/icu-small/source/common/wintz.cpp
+++ b/deps/icu-small/source/common/wintz.cpp
@@ -49,7 +49,7 @@ typedef struct
 /**
  * Various registry keys and key fragments.
  */
-static const char CURRENT_ZONE_REGKEY[] = "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation\\";
+static const wchar_t CURRENT_ZONE_REGKEY[] = L"SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation\\";
 static const char STANDARD_TIME_REGKEY[] = " Standard Time";
 static const char TZI_REGKEY[] = "TZI";
 static const char STD_REGKEY[] = "Std";
@@ -121,27 +121,39 @@ static LONG getSTDName(const char *winid, char *regStdName, int32_t length)
     return result;
 }
 
-static LONG getTZKeyName(char* tzKeyName, int32_t length)
+static LONG getTZKeyName(char* tzKeyName, int32_t tzKeyNamelength)
 {
     HKEY hkey;
     LONG result = FALSE;
-    DWORD cbData = length;
+    WCHAR timeZoneKeyNameData[128];
+    DWORD timeZoneKeyNameLength = static_cast<DWORD>(sizeof(timeZoneKeyNameData));
 
-    if(ERROR_SUCCESS == RegOpenKeyExA(
+    if(ERROR_SUCCESS == RegOpenKeyExW(
         HKEY_LOCAL_MACHINE,
         CURRENT_ZONE_REGKEY,
         0,
         KEY_QUERY_VALUE,
         &hkey))
     {
-         result = RegQueryValueExA(
+        if (ERROR_SUCCESS == RegQueryValueExW(
              hkey,
-             "TimeZoneKeyName",
+             L"TimeZoneKeyName",
              NULL,
              NULL,
-             (LPBYTE)tzKeyName,
-             &cbData);
+             (LPBYTE)timeZoneKeyNameData,
+             &timeZoneKeyNameLength))
+        {
+            // Ensure null termination.
+            timeZoneKeyNameData[UPRV_LENGTHOF(timeZoneKeyNameData) - 1] = L'\0';
 
+            // Convert the UTF-16 string to UTF-8.
+            UErrorCode status = U_ZERO_ERROR;
+            u_strToUTF8(tzKeyName, tzKeyNamelength, NULL, reinterpret_cast<const UChar *>(timeZoneKeyNameData), -1, &status);
+            if (U_ZERO_ERROR == status)
+            {
+                result = ERROR_SUCCESS;
+            }
+        }
         RegCloseKey(hkey);
     }
 
diff --git a/deps/icu-small/source/data/in/icudt61l.dat b/deps/icu-small/source/data/in/icudt62l.dat
similarity index 65%
rename from deps/icu-small/source/data/in/icudt61l.dat
rename to deps/icu-small/source/data/in/icudt62l.dat
index e9c24d8d1a78822c99efda00d11bed8a45d9eb24..a6ac7ebb374980af350e400719adeeefdb78fa70 100644
GIT binary patch
delta 459320
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

delta 443800
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
N3~sR8nCX7S{(lXxFGc_W

diff --git a/deps/icu-small/source/i18n/affixpatternparser.cpp b/deps/icu-small/source/i18n/affixpatternparser.cpp
deleted file mode 100644
index d9e122953af53e..00000000000000
--- a/deps/icu-small/source/i18n/affixpatternparser.cpp
+++ /dev/null
@@ -1,698 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: affixpatternparser.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/dcfmtsym.h"
-#include "unicode/plurrule.h"
-#include "unicode/strenum.h"
-#include "unicode/ucurr.h"
-#include "unicode/ustring.h"
-#include "affixpatternparser.h"
-#include "charstr.h"
-#include "precision.h"
-#include "uassert.h"
-#include "unistrappender.h"
-
-static const UChar gDefaultSymbols[] = {0xa4, 0xa4, 0xa4};
-
-static const UChar gPercent = 0x25;
-static const UChar gPerMill = 0x2030;
-static const UChar gNegative = 0x2D;
-static const UChar gPositive = 0x2B;
-
-#define PACK_TOKEN_AND_LENGTH(t, l) ((UChar) (((t) << 8) | (l & 0xFF)))
-
-#define UNPACK_TOKEN(c) ((AffixPattern::ETokenType) (((c) >> 8) & 0x7F))
-
-#define UNPACK_LONG(c) (((c) >> 8) & 0x80)
-
-#define UNPACK_LENGTH(c) ((c) & 0xFF)
-
-U_NAMESPACE_BEGIN
-
-static int32_t
-nextToken(const UChar *buffer, int32_t idx, int32_t len, UChar *token) {
-    if (buffer[idx] != 0x27 || idx + 1 == len) {
-        *token = buffer[idx];
-        return 1;
-    }
-    *token = buffer[idx + 1];
-    if (buffer[idx + 1] == 0xA4) {
-        int32_t i = 2;
-        for (; idx + i < len && i < 4 && buffer[idx + i] == buffer[idx + 1]; ++i)
-          ;
-        return i;
-    }
-    return 2;
-}
-
-static int32_t
-nextUserToken(const UChar *buffer, int32_t idx, int32_t len, UChar *token) {
-    *token = buffer[idx];
-    int32_t max;
-    switch (buffer[idx]) {
-    case 0x27:
-        max = 2;
-        break;
-    case 0xA4:
-        max = 3;
-        break;
-    default:
-        max = 1;
-        break;
-    }
-    int32_t i = 1;
-    for (; idx + i < len && i < max && buffer[idx + i] == buffer[idx]; ++i)
-      ;
-    return i;
-}
-
-CurrencyAffixInfo::CurrencyAffixInfo()
-        : fSymbol(gDefaultSymbols, 1),
-          fISO(gDefaultSymbols, 2),
-          fLong(DigitAffix(gDefaultSymbols, 3)),
-          fIsDefault(TRUE) {
-}
-
-void
-CurrencyAffixInfo::set(
-        const char *locale,
-        const PluralRules *rules,
-        const UChar *currency,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fIsDefault = FALSE;
-    if (currency == NULL) {
-        fSymbol.setTo(gDefaultSymbols, 1);
-        fISO.setTo(gDefaultSymbols, 2);
-        fLong.remove();
-        fLong.append(gDefaultSymbols, 3);
-        fIsDefault = TRUE;
-        return;
-    }
-    int32_t len;
-    UBool unusedIsChoice;
-    const UChar *symbol = ucurr_getName(
-            currency, locale, UCURR_SYMBOL_NAME, &unusedIsChoice,
-            &len, &status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fSymbol.setTo(symbol, len);
-    fISO.setTo(currency, u_strlen(currency));
-    fLong.remove();
-    StringEnumeration* keywords = rules->getKeywords(status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-    const UnicodeString* pluralCount;
-    while ((pluralCount = keywords->snext(status)) != NULL) {
-        CharString pCount;
-        pCount.appendInvariantChars(*pluralCount, status);
-        const UChar *pluralName = ucurr_getPluralName(
-            currency, locale, &unusedIsChoice, pCount.data(),
-            &len, &status);
-        fLong.setVariant(pCount.data(), UnicodeString(pluralName, len), status);
-    }
-    delete keywords;
-}
-
-void
-CurrencyAffixInfo::adjustPrecision(
-        const UChar *currency, const UCurrencyUsage usage,
-        FixedPrecision &precision, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    int32_t digitCount = ucurr_getDefaultFractionDigitsForUsage(
-            currency, usage, &status);
-    precision.fMin.setFracDigitCount(digitCount);
-    precision.fMax.setFracDigitCount(digitCount);
-    double increment = ucurr_getRoundingIncrementForUsage(
-            currency, usage, &status);
-    if (increment == 0.0) {
-        precision.fRoundingIncrement.clear();
-    } else {
-        precision.fRoundingIncrement.set(increment);
-        // guard against round-off error
-        precision.fRoundingIncrement.round(6);
-    }
-}
-
-void
-AffixPattern::addLiteral(
-        const UChar *literal, int32_t start, int32_t len) {
-    char32Count += u_countChar32(literal + start, len);
-    literals.append(literal, start, len);
-    int32_t tlen = tokens.length();
-    // Takes 4 UChars to encode maximum literal length.
-    UChar *tokenChars = tokens.getBuffer(tlen + 4);
-
-    // find start of literal size. May be tlen if there is no literal.
-    // While finding start of literal size, compute literal length
-    int32_t literalLength = 0;
-    int32_t tLiteralStart = tlen;
-    while (tLiteralStart > 0 && UNPACK_TOKEN(tokenChars[tLiteralStart - 1]) == kLiteral) {
-        tLiteralStart--;
-        literalLength <<= 8;
-        literalLength |= UNPACK_LENGTH(tokenChars[tLiteralStart]);
-    }
-    // Add number of chars we just added to literal
-    literalLength += len;
-
-    // Now encode the new length starting at tLiteralStart
-    tlen = tLiteralStart;
-    tokenChars[tlen++] = PACK_TOKEN_AND_LENGTH(kLiteral, literalLength & 0xFF);
-    literalLength >>= 8;
-    while (literalLength) {
-        tokenChars[tlen++] = PACK_TOKEN_AND_LENGTH(kLiteral | 0x80, literalLength & 0xFF);
-        literalLength >>= 8;
-    }
-    tokens.releaseBuffer(tlen);
-}
-
-void
-AffixPattern::add(ETokenType t) {
-    add(t, 1);
-}
-
-void
-AffixPattern::addCurrency(uint8_t count) {
-    add(kCurrency, count);
-}
-
-void
-AffixPattern::add(ETokenType t, uint8_t count) {
-    U_ASSERT(t != kLiteral);
-    char32Count += count;
-    switch (t) {
-    case kCurrency:
-        hasCurrencyToken = TRUE;
-        break;
-    case kPercent:
-        hasPercentToken = TRUE;
-        break;
-    case kPerMill:
-        hasPermillToken = TRUE;
-        break;
-    default:
-        // Do nothing
-        break;
-    }
-    tokens.append(PACK_TOKEN_AND_LENGTH(t, count));
-}
-
-AffixPattern &
-AffixPattern::append(const AffixPattern &other) {
-    AffixPatternIterator iter;
-    other.iterator(iter);
-    UnicodeString literal;
-    while (iter.nextToken()) {
-        switch (iter.getTokenType()) {
-        case kLiteral:
-            iter.getLiteral(literal);
-            addLiteral(literal.getBuffer(), 0, literal.length());
-            break;
-        case kCurrency:
-            addCurrency(static_cast<uint8_t>(iter.getTokenLength()));
-            break;
-        default:
-            add(iter.getTokenType());
-            break;
-        }
-    }
-    return *this;
-}
-
-void
-AffixPattern::remove() {
-    tokens.remove();
-    literals.remove();
-    hasCurrencyToken = FALSE;
-    hasPercentToken = FALSE;
-    hasPermillToken = FALSE;
-    char32Count = 0;
-}
-
-// escapes literals for strings where special characters are NOT escaped
-// except for apostrophe.
-static void escapeApostropheInLiteral(
-        const UnicodeString &literal, UnicodeStringAppender &appender) {
-    int32_t len = literal.length();
-    const UChar *buffer = literal.getBuffer();
-    for (int32_t i = 0; i < len; ++i) {
-        UChar ch = buffer[i];
-        switch (ch) {
-            case 0x27:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x27);
-                break;
-            default:
-                appender.append(ch);
-                break;
-        }
-    }
-}
-
-
-// escapes literals for user strings where special characters in literals
-// are escaped with apostrophe.
-static void escapeLiteral(
-        const UnicodeString &literal, UnicodeStringAppender &appender) {
-    int32_t len = literal.length();
-    const UChar *buffer = literal.getBuffer();
-    for (int32_t i = 0; i < len; ++i) {
-        UChar ch = buffer[i];
-        switch (ch) {
-            case 0x27:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x27);
-                break;
-            case 0x25:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x25);
-                appender.append((UChar) 0x27);
-                break;
-            case 0x2030:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x2030);
-                appender.append((UChar) 0x27);
-                break;
-            case 0xA4:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0xA4);
-                appender.append((UChar) 0x27);
-                break;
-            case 0x2D:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x2D);
-                appender.append((UChar) 0x27);
-                break;
-            case 0x2B:
-                appender.append((UChar) 0x27);
-                appender.append((UChar) 0x2B);
-                appender.append((UChar) 0x27);
-                break;
-            default:
-                appender.append(ch);
-                break;
-        }
-    }
-}
-
-UnicodeString &
-AffixPattern::toString(UnicodeString &appendTo) const {
-    AffixPatternIterator iter;
-    iterator(iter);
-    UnicodeStringAppender appender(appendTo);
-    UnicodeString literal;
-    while (iter.nextToken()) {
-        switch (iter.getTokenType()) {
-        case kLiteral:
-            escapeApostropheInLiteral(iter.getLiteral(literal), appender);
-            break;
-        case kPercent:
-            appender.append((UChar) 0x27);
-            appender.append((UChar) 0x25);
-            break;
-        case kPerMill:
-            appender.append((UChar) 0x27);
-            appender.append((UChar) 0x2030);
-            break;
-        case kCurrency:
-            {
-                appender.append((UChar) 0x27);
-                int32_t cl = iter.getTokenLength();
-                for (int32_t i = 0; i < cl; ++i) {
-                    appender.append((UChar) 0xA4);
-                }
-            }
-            break;
-        case kNegative:
-            appender.append((UChar) 0x27);
-            appender.append((UChar) 0x2D);
-            break;
-        case kPositive:
-            appender.append((UChar) 0x27);
-            appender.append((UChar) 0x2B);
-            break;
-        default:
-            U_ASSERT(FALSE);
-            break;
-        }
-    }
-    return appendTo;
-}
-
-UnicodeString &
-AffixPattern::toUserString(UnicodeString &appendTo) const {
-    AffixPatternIterator iter;
-    iterator(iter);
-    UnicodeStringAppender appender(appendTo);
-    UnicodeString literal;
-    while (iter.nextToken()) {
-        switch (iter.getTokenType()) {
-        case kLiteral:
-            escapeLiteral(iter.getLiteral(literal), appender);
-            break;
-        case kPercent:
-            appender.append((UChar) 0x25);
-            break;
-        case kPerMill:
-            appender.append((UChar) 0x2030);
-            break;
-        case kCurrency:
-            {
-                int32_t cl = iter.getTokenLength();
-                for (int32_t i = 0; i < cl; ++i) {
-                    appender.append((UChar) 0xA4);
-                }
-            }
-            break;
-        case kNegative:
-            appender.append((UChar) 0x2D);
-            break;
-        case kPositive:
-            appender.append((UChar) 0x2B);
-            break;
-        default:
-            U_ASSERT(FALSE);
-            break;
-        }
-    }
-    return appendTo;
-}
-
-class AffixPatternAppender : public UMemory {
-public:
-    AffixPatternAppender(AffixPattern &dest) : fDest(&dest), fIdx(0) { }
-
-    inline void append(UChar x) {
-        if (fIdx == UPRV_LENGTHOF(fBuffer)) {
-            fDest->addLiteral(fBuffer, 0, fIdx);
-            fIdx = 0;
-        }
-        fBuffer[fIdx++] = x;
-    }
-
-    inline void append(UChar32 x) {
-        if (fIdx >= UPRV_LENGTHOF(fBuffer) - 1) {
-            fDest->addLiteral(fBuffer, 0, fIdx);
-            fIdx = 0;
-        }
-        U16_APPEND_UNSAFE(fBuffer, fIdx, x);
-    }
-
-    inline void flush() {
-        if (fIdx) {
-            fDest->addLiteral(fBuffer, 0, fIdx);
-        }
-        fIdx = 0;
-    }
-
-    /**
-     * flush the buffer when we go out of scope.
-     */
-    ~AffixPatternAppender() {
-        flush();
-    }
-private:
-    AffixPattern *fDest;
-    int32_t fIdx;
-    UChar fBuffer[32];
-    AffixPatternAppender(const AffixPatternAppender &other);
-    AffixPatternAppender &operator=(const AffixPatternAppender &other);
-};
-
-
-AffixPattern &
-AffixPattern::parseUserAffixString(
-        const UnicodeString &affixStr,
-        AffixPattern &appendTo,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    int32_t len = affixStr.length();
-    const UChar *buffer = affixStr.getBuffer();
-    // 0 = not quoted; 1 = quoted.
-    int32_t state = 0;
-    AffixPatternAppender appender(appendTo);
-    for (int32_t i = 0; i < len; ) {
-        UChar token;
-        int32_t tokenSize = nextUserToken(buffer, i, len, &token);
-        i += tokenSize;
-        if (token == 0x27 && tokenSize == 1) { // quote
-            state = 1 - state;
-            continue;
-        }
-        if (state == 0) {
-            switch (token) {
-            case 0x25:
-                appender.flush();
-                appendTo.add(kPercent, 1);
-                break;
-            case 0x27:  // double quote
-                appender.append((UChar) 0x27);
-                break;
-            case 0x2030:
-                appender.flush();
-                appendTo.add(kPerMill, 1);
-                break;
-            case 0x2D:
-                appender.flush();
-                appendTo.add(kNegative, 1);
-                break;
-            case 0x2B:
-                appender.flush();
-                appendTo.add(kPositive, 1);
-                break;
-            case 0xA4:
-                appender.flush();
-                appendTo.add(kCurrency, static_cast<uint8_t>(tokenSize));
-                break;
-            default:
-                appender.append(token);
-                break;
-            }
-        } else {
-            switch (token) {
-            case 0x27:  // double quote
-                appender.append((UChar) 0x27);
-                break;
-            case 0xA4: // included b/c tokenSize can be > 1
-                for (int32_t j = 0; j < tokenSize; ++j) {
-                    appender.append((UChar) 0xA4);
-                }
-                break;
-            default:
-                appender.append(token);
-                break;
-            }
-        }
-    }
-    return appendTo;
-}
-
-AffixPattern &
-AffixPattern::parseAffixString(
-        const UnicodeString &affixStr,
-        AffixPattern &appendTo,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    int32_t len = affixStr.length();
-    const UChar *buffer = affixStr.getBuffer();
-    for (int32_t i = 0; i < len; ) {
-        UChar token;
-        int32_t tokenSize = nextToken(buffer, i, len, &token);
-        if (tokenSize == 1) {
-            int32_t literalStart = i;
-            ++i;
-            while (i < len && (tokenSize = nextToken(buffer, i, len, &token)) == 1) {
-                ++i;
-            }
-            appendTo.addLiteral(buffer, literalStart, i - literalStart);
-
-            // If we reached end of string, we are done
-            if (i == len) {
-                return appendTo;
-            }
-        }
-        i += tokenSize;
-        switch (token) {
-        case 0x25:
-            appendTo.add(kPercent, 1);
-            break;
-        case 0x2030:
-            appendTo.add(kPerMill, 1);
-            break;
-        case 0x2D:
-            appendTo.add(kNegative, 1);
-            break;
-        case 0x2B:
-            appendTo.add(kPositive, 1);
-            break;
-        case 0xA4:
-            {
-                if (tokenSize - 1 > 3) {
-                    status = U_PARSE_ERROR;
-                    return appendTo;
-                }
-                appendTo.add(kCurrency, tokenSize - 1);
-            }
-            break;
-        default:
-            appendTo.addLiteral(&token, 0, 1);
-            break;
-        }
-    }
-    return appendTo;
-}
-
-AffixPatternIterator &
-AffixPattern::iterator(AffixPatternIterator &result) const {
-    result.nextLiteralIndex = 0;
-    result.lastLiteralLength = 0;
-    result.nextTokenIndex = 0;
-    result.tokens = &tokens;
-    result.literals = &literals;
-    return result;
-}
-
-UBool
-AffixPatternIterator::nextToken() {
-    int32_t tlen = tokens->length();
-    if (nextTokenIndex == tlen) {
-        return FALSE;
-    }
-    ++nextTokenIndex;
-    const UChar *tokenBuffer = tokens->getBuffer();
-    if (UNPACK_TOKEN(tokenBuffer[nextTokenIndex - 1]) ==
-            AffixPattern::kLiteral) {
-        while (nextTokenIndex < tlen &&
-                UNPACK_LONG(tokenBuffer[nextTokenIndex])) {
-            ++nextTokenIndex;
-        }
-        lastLiteralLength = 0;
-        int32_t i = nextTokenIndex - 1;
-        for (; UNPACK_LONG(tokenBuffer[i]); --i) {
-            lastLiteralLength <<= 8;
-            lastLiteralLength |= UNPACK_LENGTH(tokenBuffer[i]);
-        }
-        lastLiteralLength <<= 8;
-        lastLiteralLength |= UNPACK_LENGTH(tokenBuffer[i]);
-        nextLiteralIndex += lastLiteralLength;
-    }
-    return TRUE;
-}
-
-AffixPattern::ETokenType
-AffixPatternIterator::getTokenType() const {
-    return UNPACK_TOKEN(tokens->charAt(nextTokenIndex - 1));
-}
-
-UnicodeString &
-AffixPatternIterator::getLiteral(UnicodeString &result) const {
-    const UChar *buffer = literals->getBuffer();
-    result.setTo(buffer + (nextLiteralIndex - lastLiteralLength), lastLiteralLength);
-    return result;
-}
-
-int32_t
-AffixPatternIterator::getTokenLength() const {
-    const UChar *tokenBuffer = tokens->getBuffer();
-    AffixPattern::ETokenType type = UNPACK_TOKEN(tokenBuffer[nextTokenIndex - 1]);
-    return type == AffixPattern::kLiteral ? lastLiteralLength : UNPACK_LENGTH(tokenBuffer[nextTokenIndex - 1]);
-}
-
-AffixPatternParser::AffixPatternParser()
-        : fPercent(gPercent), fPermill(gPerMill), fNegative(gNegative), fPositive(gPositive) {
-}
-
-AffixPatternParser::AffixPatternParser(
-        const DecimalFormatSymbols &symbols) {
-    setDecimalFormatSymbols(symbols);
-}
-
-void
-AffixPatternParser::setDecimalFormatSymbols(
-        const DecimalFormatSymbols &symbols) {
-    fPercent = symbols.getConstSymbol(DecimalFormatSymbols::kPercentSymbol);
-    fPermill = symbols.getConstSymbol(DecimalFormatSymbols::kPerMillSymbol);
-    fNegative = symbols.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
-    fPositive = symbols.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
-}
-
-PluralAffix &
-AffixPatternParser::parse(
-        const AffixPattern &affixPattern,
-        const CurrencyAffixInfo &currencyAffixInfo,
-        PluralAffix &appendTo,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    AffixPatternIterator iter;
-    affixPattern.iterator(iter);
-    UnicodeString literal;
-    while (iter.nextToken()) {
-        switch (iter.getTokenType()) {
-        case AffixPattern::kPercent:
-            appendTo.append(fPercent, UNUM_PERCENT_FIELD);
-            break;
-        case AffixPattern::kPerMill:
-            appendTo.append(fPermill, UNUM_PERMILL_FIELD);
-            break;
-        case AffixPattern::kNegative:
-            appendTo.append(fNegative, UNUM_SIGN_FIELD);
-            break;
-        case AffixPattern::kPositive:
-            appendTo.append(fPositive, UNUM_SIGN_FIELD);
-            break;
-        case AffixPattern::kCurrency:
-            switch (iter.getTokenLength()) {
-                case 1:
-                    appendTo.append(
-                            currencyAffixInfo.getSymbol(), UNUM_CURRENCY_FIELD);
-                    break;
-                case 2:
-                    appendTo.append(
-                            currencyAffixInfo.getISO(), UNUM_CURRENCY_FIELD);
-                    break;
-                case 3:
-                    appendTo.append(
-                            currencyAffixInfo.getLong(), UNUM_CURRENCY_FIELD, status);
-                    break;
-                default:
-                    U_ASSERT(FALSE);
-                    break;
-            }
-            break;
-        case AffixPattern::kLiteral:
-            appendTo.append(iter.getLiteral(literal));
-            break;
-        default:
-            U_ASSERT(FALSE);
-            break;
-        }
-    }
-    return appendTo;
-}
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/affixpatternparser.h b/deps/icu-small/source/i18n/affixpatternparser.h
deleted file mode 100644
index b54c749c700816..00000000000000
--- a/deps/icu-small/source/i18n/affixpatternparser.h
+++ /dev/null
@@ -1,402 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* affixpatternparser.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __AFFIX_PATTERN_PARSER_H__
-#define __AFFIX_PATTERN_PARSER_H__
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/unistr.h"
-#include "unicode/uobject.h"
-#include "pluralaffix.h"
-
-U_NAMESPACE_BEGIN
-
-class PluralRules;
-class FixedPrecision;
-class DecimalFormatSymbols;
-
-/**
- * A representation of the various forms of a particular currency according
- * to some locale and usage context.
- *
- * Includes the symbol, ISO code form, and long form(s) of the currency name
- * for each plural variation.
- */
-class U_I18N_API CurrencyAffixInfo : public UMemory {
-public:
-    /**
-     * Symbol is \u00a4; ISO form is \u00a4\u00a4;
-     *  long form is \u00a4\u00a4\u00a4.
-     */
-    CurrencyAffixInfo();
-
-    const UnicodeString &getSymbol() const { return fSymbol; }
-    const UnicodeString &getISO() const { return fISO; }
-    const PluralAffix &getLong() const { return fLong; }
-    void setSymbol(const UnicodeString &symbol) {
-        fSymbol = symbol;
-        fIsDefault = FALSE;
-    }
-    void setISO(const UnicodeString &iso) {
-        fISO = iso;
-        fIsDefault = FALSE;
-    }
-    UBool
-    equals(const CurrencyAffixInfo &other) const {
-        return (fSymbol == other.fSymbol)
-                && (fISO == other.fISO)
-                && (fLong.equals(other.fLong))
-                && (fIsDefault == other.fIsDefault);
-    }
-
-    /**
-     * Intializes this instance.
-     *
-     * @param locale the locale for the currency forms.
-     * @param rules The plural rules for the locale.
-     * @param currency the null terminated, 3 character ISO code of the
-     * currency. If NULL, resets this instance as if it were just created.
-     * In this case, the first 2 parameters may be NULL as well.
-     * @param status any error returned here.
-     */
-    void set(
-            const char *locale, const PluralRules *rules,
-            const UChar *currency, UErrorCode &status);
-
-    /**
-     * Returns true if this instance is the default. That is has no real
-     * currency. For instance never initialized with set()
-     * or reset with set(NULL, NULL, NULL, status).
-     */
-    UBool isDefault() const { return fIsDefault; }
-
-    /**
-     * Adjusts the precision used for a particular currency.
-     * @param currency the null terminated, 3 character ISO code of the
-     * currency.
-     * @param usage the usage of the currency
-     * @param precision min/max fraction digits and rounding increment
-     *  adjusted.
-     * @params status any error reported here.
-     */
-    static void adjustPrecision(
-            const UChar *currency, const UCurrencyUsage usage,
-            FixedPrecision &precision, UErrorCode &status);
-
-private:
-    /**
-     * The symbol form of the currency.
-     */
-    UnicodeString fSymbol;
-
-    /**
-     * The ISO form of the currency, usually three letter abbreviation.
-     */
-    UnicodeString fISO;
-
-    /**
-     * The long forms of the currency keyed by plural variation.
-     */
-    PluralAffix fLong;
-
-    UBool fIsDefault;
-
-};
-
-class AffixPatternIterator;
-
-/**
- * A locale agnostic representation of an affix pattern.
- */
-class U_I18N_API AffixPattern : public UMemory {
-public:
-
-    /**
-     * The token types that can appear in an affix pattern.
-     */
-    enum ETokenType {
-        kLiteral,
-        kPercent,
-        kPerMill,
-        kCurrency,
-        kNegative,
-        kPositive
-    };
-
-    /**
-     * An empty affix pattern.
-     */
-    AffixPattern()
-            : tokens(), literals(), hasCurrencyToken(FALSE),
-              hasPercentToken(FALSE), hasPermillToken(FALSE),  char32Count(0) {
-    }
-
-    /**
-     * Adds a string literal to this affix pattern.
-     */
-    void addLiteral(const UChar *, int32_t start, int32_t len);
-
-    /**
-     * Adds a token to this affix pattern. t must not be kLiteral as
-     * the addLiteral() method adds literals.
-     * @param t the token type to add
-     */
-    void add(ETokenType t);
-
-    /**
-     * Adds a currency token with specific count to this affix pattern.
-     * @param count the token count. Used to distinguish between
-     *  one, two, or three currency symbols. Note that adding a currency
-     *  token with count=2 (Use ISO code) is different than adding two
-     *  currency tokens each with count=1 (two currency symbols).
-     */
-    void addCurrency(uint8_t count);
-
-    /**
-     * Makes this instance be an empty affix pattern.
-     */
-    void remove();
-
-    /**
-     * Provides an iterator over the tokens in this instance.
-     * @param result this is initialized to point just before the
-     *   first token of this instance. Caller must call nextToken()
-     *   on the iterator once it is set up to have it actually point
-     *   to the first token. This first call to nextToken() will return
-     *   FALSE if the AffixPattern being iterated over is empty.
-     * @return result
-     */
-    AffixPatternIterator &iterator(AffixPatternIterator &result) const;
-
-    /**
-     * Returns TRUE if this instance has currency tokens in it.
-     */
-    UBool usesCurrency() const {
-        return hasCurrencyToken;
-    }
-
-    UBool usesPercent() const {
-        return hasPercentToken;
-    }
-
-    UBool usesPermill() const {
-        return hasPermillToken;
-    }
-
-    /**
-     * Returns the number of code points a string of this instance
-     * would have if none of the special tokens were escaped.
-     * Used to compute the padding size.
-     */
-    int32_t countChar32() const {
-        return char32Count;
-    }
-
-    /**
-     * Appends other to this instance mutating this instance in place.
-     * @param other The pattern appended to the end of this one.
-     * @return a reference to this instance for chaining.
-     */
-    AffixPattern &append(const AffixPattern &other);
-
-    /**
-     * Converts this AffixPattern back into a user string.
-     * It is the inverse of parseUserAffixString.
-     */
-    UnicodeString &toUserString(UnicodeString &appendTo) const;
-
-    /**
-     * Converts this AffixPattern back into a string.
-     * It is the inverse of parseAffixString.
-     */
-    UnicodeString &toString(UnicodeString &appendTo) const;
-
-    /**
-     * Parses an affix pattern string appending it to an AffixPattern.
-     * Parses affix pattern strings produced from using
-     * DecimalFormatPatternParser to parse a format pattern. Affix patterns
-     * include the positive prefix and suffix and the negative prefix
-     * and suffix. This method expects affix patterns strings to be in the
-     * same format that DecimalFormatPatternParser produces. Namely special
-     * characters in the affix that correspond to a field type must be
-     * prefixed with an apostrophe ('). These special character sequences
-     * inluce minus (-), percent (%), permile (U+2030), plus (+),
-     * short currency (U+00a4), medium currency (u+00a4 * 2),
-     * long currency (u+a4 * 3), and apostrophe (')
-     * (apostrophe does not correspond to a field type but has to be escaped
-     * because it itself is the escape character).
-     * Since the expansion of these special character
-     * sequences is locale dependent, these sequences are not expanded in
-     * an AffixPattern instance.
-     * If these special characters are not prefixed with an apostrophe in
-     * the affix pattern string, then they are treated verbatim just as
-     * any other character. If an apostrophe prefixes a non special
-     * character in the affix pattern, the apostrophe is simply ignored.
-     *
-     * @param affixStr the string from DecimalFormatPatternParser
-     * @param appendTo parsed result appended here.
-     * @param status any error parsing returned here.
-     */
-    static AffixPattern &parseAffixString(
-            const UnicodeString &affixStr,
-            AffixPattern &appendTo,
-            UErrorCode &status);
-
-    /**
-     * Parses an affix pattern string appending it to an AffixPattern.
-     * Parses affix pattern strings as the user would supply them.
-     * In this function, quoting makes special characters like normal
-     * characters whereas in parseAffixString, quoting makes special
-     * characters special.
-     *
-     * @param affixStr the string from the user
-     * @param appendTo parsed result appended here.
-     * @param status any error parsing returned here.
-     */
-    static AffixPattern &parseUserAffixString(
-            const UnicodeString &affixStr,
-            AffixPattern &appendTo,
-            UErrorCode &status);
-
-    UBool equals(const AffixPattern &other) const {
-        return (tokens == other.tokens)
-                && (literals == other.literals)
-                && (hasCurrencyToken == other.hasCurrencyToken)
-                && (hasPercentToken == other.hasPercentToken)
-                && (hasPermillToken == other.hasPermillToken)
-                && (char32Count == other.char32Count);
-    }
-
-private:
-    /*
-     * Tokens stored here. Each UChar generally stands for one token. A
-     * Each token is of form 'etttttttllllllll' llllllll is the length of
-     * the token and ranges from 0-255. ttttttt is the token type and ranges
-     * from 0-127. If e is set it means this is an extendo token (to be
-     * described later). To accomodate token lengths above 255, each normal
-     * token (e=0) can be followed by 0 or more extendo tokens (e=1) with
-     * the same type. Right now only kLiteral Tokens have extendo tokens.
-     * Each extendo token provides the next 8 higher bits for the length.
-     * If a kLiteral token is followed by 2 extendo tokens then, then the
-     * llllllll of the next extendo token contains bits 8-15 of the length
-     * and the last extendo token contains bits 16-23 of the length.
-     */
-    UnicodeString tokens;
-
-    /*
-     * The characters of the kLiteral tokens are concatenated together here.
-     * The first characters go with the first kLiteral token, the next
-     * characters go with the next kLiteral token etc.
-     */
-    UnicodeString literals;
-    UBool hasCurrencyToken;
-    UBool hasPercentToken;
-    UBool hasPermillToken;
-    int32_t char32Count;
-    void add(ETokenType t, uint8_t count);
-
-};
-
-/**
- * An iterator over the tokens in an AffixPattern instance.
- */
-class U_I18N_API AffixPatternIterator : public UMemory {
-public:
-
-    /**
-     * Using an iterator without first calling iterator on an AffixPattern
-     * instance to initialize the iterator results in
-     * undefined behavior.
-     */
-    AffixPatternIterator() : nextLiteralIndex(0), lastLiteralLength(0), nextTokenIndex(0), tokens(NULL), literals(NULL) { }
-    /**
-     * Advances this iterator to the next token. Returns FALSE when there
-     * are no more tokens. Calling the other methods after nextToken()
-     * returns FALSE results in undefined behavior.
-     */
-    UBool nextToken();
-
-    /**
-     * Returns the type of token.
-     */
-    AffixPattern::ETokenType getTokenType() const;
-
-    /**
-     * For literal tokens, returns the literal string. Calling this for
-     * other token types results in undefined behavior.
-     * @param result replaced with a read-only alias to the literal string.
-     * @return result
-     */
-    UnicodeString &getLiteral(UnicodeString &result) const;
-
-    /**
-     * Returns the token length. Usually 1, but for currency tokens may
-     * be 2 for ISO code and 3 for long form.
-     */
-    int32_t getTokenLength() const;
-private:
-    int32_t nextLiteralIndex;
-    int32_t lastLiteralLength;
-    int32_t nextTokenIndex;
-    const UnicodeString *tokens;
-    const UnicodeString *literals;
-    friend class AffixPattern;
-    AffixPatternIterator(const AffixPatternIterator &);
-    AffixPatternIterator &operator=(const AffixPatternIterator &);
-};
-
-/**
- * A locale aware class that converts locale independent AffixPattern
- * instances into locale dependent PluralAffix instances.
- */
-class U_I18N_API AffixPatternParser : public UMemory {
-public:
-AffixPatternParser();
-AffixPatternParser(const DecimalFormatSymbols &symbols);
-void setDecimalFormatSymbols(const DecimalFormatSymbols &symbols);
-
-/**
- * Parses affixPattern appending the result to appendTo.
- * @param affixPattern The affix pattern.
- * @param currencyAffixInfo contains the currency forms.
- * @param appendTo The result of parsing affixPattern is appended here.
- * @param status any error returned here.
- * @return appendTo.
- */
-PluralAffix &parse(
-        const AffixPattern &affixPattern,
-        const CurrencyAffixInfo &currencyAffixInfo,
-        PluralAffix &appendTo,
-        UErrorCode &status) const;
-
-UBool equals(const AffixPatternParser &other) const {
-    return (fPercent == other.fPercent)
-            && (fPermill == other.fPermill)
-            && (fNegative == other.fNegative)
-            && (fPositive == other.fPositive);
-}
-
-private:
-UnicodeString fPercent;
-UnicodeString fPermill;
-UnicodeString fNegative;
-UnicodeString fPositive;
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif  // __AFFIX_PATTERN_PARSER_H__
diff --git a/deps/icu-small/source/i18n/collationfcd.cpp b/deps/icu-small/source/i18n/collationfcd.cpp
index 19841ee6487ad2..1aff936dee1d2a 100644
--- a/deps/icu-small/source/i18n/collationfcd.cpp
+++ b/deps/icu-small/source/i18n/collationfcd.cpp
@@ -22,27 +22,27 @@ const uint8_t CollationFCD::lcccIndex[2048]={
 0,0,0,0,0,0,0,0,1,1,2,3,0,0,0,0,
 0,0,0,0,4,0,0,0,0,0,0,0,5,6,7,0,
 8,0,9,0xa,0,0,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0x10,
-0x11,0x12,0x13,0,0,0,0x14,0x15,0,0x16,0x17,0,0,0x16,0x18,0,
+0x11,0x12,0x13,0,0,0,0x14,0x15,0,0x16,0x17,0,0,0x16,0x18,0x19,
 0,0x16,0x18,0,0,0x16,0x18,0,0,0x16,0x18,0,0,0,0x18,0,
-0,0,0x19,0,0,0x16,0x18,0,0,0x1a,0x18,0,0,0,0x1b,0,
-0,0x1c,0x1d,0,0,0x1e,0x1d,0,0x1e,0x1f,0,0x20,0x21,0,0x22,0,
-0,0x23,0,0,0x18,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x24,0,0,0,0,0,
+0,0,0x1a,0,0,0x16,0x18,0,0,0x1b,0x18,0,0,0,0x1c,0,
+0,0x1d,0x1e,0,0,0x1f,0x1e,0,0x1f,0x20,0,0x21,0x22,0,0x23,0,
+0,0x24,0,0,0x18,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x25,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x25,0x25,0,0,0,0,0x26,0,
-0,0,0,0,0,0x27,0,0,0,0x13,0,0,0,0,0,0,
-0x28,0,0,0x29,0,0x2a,0,0,0,0x25,0x2b,0x10,0,0x2c,0,0x2d,
-0,0x2e,0,0,0,0,0x2f,0x30,0,0,0,0,0,0,1,0x31,
+0,0,0,0,0,0,0,0,0x26,0x26,0,0,0,0,0x27,0,
+0,0,0,0,0,0x28,0,0,0,0x13,0,0,0,0,0,0,
+0x29,0,0,0x2a,0,0x2b,0,0,0,0x26,0x2c,0x2d,0,0x2e,0,0x2f,
+0,0x30,0,0,0,0,0x31,0x32,0,0,0,0,0,0,1,0x33,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0x32,0x33,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0x34,0x35,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x34,0,0,0,0x35,0,0,0,1,
+0,0,0,0,0,0,0,0x36,0,0,0,0x37,0,0,0,1,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0x36,0,0,0x37,0,0,0,0,0,0,0,0,0,0,0,
+0,0x38,0,0,0x39,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -101,9 +101,9 @@ const uint8_t CollationFCD::lcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x38,0x39,0,0,0x3a,0,0,0,0,0,0,0,0,
-0x22,0,0,0,0,0,0x2b,0x3b,0,0x3c,0x3d,0,0,0x3d,0x3e,0,
-0,0,0,0,0,0x3f,0x40,0x41,0,0,0,0,0,0,0,0x18,
+0,0,0,0x3a,0x3b,0,0,0x3c,0,0,0,0,0,0,0,0,
+0x23,0,0,0,0,0,0x2c,0x3d,0,0x3e,0x3f,0,0,0x3f,0x40,0,
+0,0,0,0,0,0x41,0x42,0x43,0,0,0,0,0,0,0,0x18,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -126,7 +126,7 @@ const uint8_t CollationFCD::lcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x42,0x43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x44,0x45,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
@@ -143,17 +143,17 @@ const uint8_t CollationFCD::lcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x44,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x19,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 };
 
-const uint32_t CollationFCD::lcccBits[69]={
+const uint32_t CollationFCD::lcccBits[70]={
 0,0xffffffff,0xffff7fff,0xffff,0xf8,0xfffe0000,0xbfffffff,0xb6,0x7ff0000,0xfffff800,0x10000,0x9fc00000,0x3d9f,0x20000,0xffff0000,0x7ff,
-0xff800,0xfbc00000,0x3eef,0xe000000,0xfff00000,0xfffffffb,0x10000000,0x1e2000,0x2000,0x602000,0x18000000,0x400,0x7000000,0xf00,0x3000000,0x2a00000,
-0x3c3e0000,0xdf,0x40,0x6800000,0xe0000000,0x100000,0x20040000,0x200,0x1800000,0x9fe00001,0x3fff0000,0x10,0xc00,0xc0040,0x800000,0xfff70000,
-0x31021fd,0xfbffffff,0x1fff0000,0x1ffe2,0x38000,0x80000000,0xfc00,0x6000000,0x3ff08000,0xc0000000,0x30000,0x3ffff,0x3800,0x80000,1,0xc19d0000,
-2,0x400000,0x40000f5,0x5108000,0x40000000
+0x200ff800,0xfbc00000,0x3eef,0xe000000,0xfff80000,0xfffffffb,0x10000000,0x1e2000,0x2000,0x40000000,0x602000,0x18000000,0x400,0x7000000,0xf00,0x3000000,
+0x2a00000,0x3c3e0000,0xdf,0x40,0x6800000,0xe0000000,0x100000,0x20040000,0x200,0x1800000,0x9fe00001,0x3fff0000,0x10,0xff800,0xc00,0xc0040,
+0x800000,0xfff70000,0x31021fd,0xfbffffff,0x1fff0000,0x1ffe2,0x38000,0x80000000,0xfc00,0x6000000,0x3ff08000,0xc0000000,0x30000,0x3ffff,0x3800,0x80000,
+1,0xc19d0000,2,0x400000,0x40000fd,0x5108000
 };
 
 const uint8_t CollationFCD::tcccIndex[2048]={
@@ -161,27 +161,27 @@ const uint8_t CollationFCD::tcccIndex[2048]={
 0xb,0xc,0,0,0,0,0,0,1,1,0xd,0xe,0xf,0x10,0x11,0,
 0x12,0x13,0x14,0x15,0x16,0,0x17,0x18,0,0,0,0,0x19,0x1a,0x1b,0,
 0x1c,0x1d,0x1e,0x1f,0,0,0x20,0x21,0x22,0x23,0x24,0,0,0,0,0x25,
-0x26,0x27,0x28,0,0,0,0x29,0x2a,0,0x2b,0x2c,0,0,0x2d,0x2e,0,
-0,0x2f,0x30,0,0,0x2d,0x31,0,0,0x2d,0x32,0,0,0,0x31,0,
-0,0,0x33,0,0,0x2d,0x31,0,0,0x34,0x31,0,0,0,0x35,0,
-0,0x36,0x37,0,0,0x38,0x37,0,0x38,0x39,0,0x3a,0x3b,0,0x3c,0,
-0,0x3d,0,0,0x31,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0x3e,0,0,0,0,0,
+0x26,0x27,0x28,0,0,0,0x29,0x2a,0,0x2b,0x2c,0,0,0x2d,0x2e,0x2f,
+0,0x30,0x31,0,0,0x2d,0x32,0,0,0x2d,0x33,0,0,0,0x32,0,
+0,0,0x34,0,0,0x2d,0x32,0,0,0x35,0x32,0,0,0,0x36,0,
+0,0x37,0x38,0,0,0x39,0x38,0,0x39,0x3a,0,0x3b,0x3c,0,0x3d,0,
+0,0x3e,0,0,0x32,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0x3f,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x3f,0x3f,0,0,0,0,0x40,0,
-0,0,0,0,0,0x41,0,0,0,0x28,0,0,0,0,0,0,
-0x42,0,0,0x43,0,0x44,0,0,0,0x3f,0x45,0x25,0,0x46,0,0x47,
-0,0x48,0,0,0,0,0x49,0x4a,0,0,0,0,0,0,1,0x4b,
-1,1,1,1,0x4c,1,1,0x4d,0x4e,1,0x4f,0x50,1,0x51,0x52,0x53,
-0,0,0,0,0,0,0x54,0x55,0,0x56,0,0,0x57,0x58,0x59,0,
-0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0,0x60,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x40,0x40,0,0,0,0,0x41,0,
+0,0,0,0,0,0x42,0,0,0,0x28,0,0,0,0,0,0,
+0x43,0,0,0x44,0,0x45,0,0,0,0x40,0x46,0x47,0,0x48,0,0x49,
+0,0x4a,0,0,0,0,0x4b,0x4c,0,0,0,0,0,0,1,0x4d,
+1,1,1,1,0x4e,1,1,0x4f,0x50,1,0x51,0x52,1,0x53,0x54,0x55,
+0,0,0,0,0,0,0x56,0x57,0,0x58,0,0,0x59,0x5a,0x5b,0,
+0x5c,0x5d,0x5e,0x5f,0x60,0x61,0,0x62,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0x2d,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0x61,0,0,0,0x62,0,0,0,1,
+0,0,0,0,0,0,0,0x63,0,0,0,0x64,0,0,0,1,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0x63,0x64,0x65,0x66,0x64,0x65,0x67,0,0,0,0,0,0,0,0,
+0,0x65,0x66,0x67,0x68,0x66,0x67,0x69,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -240,9 +240,9 @@ const uint8_t CollationFCD::tcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0x68,0x69,0,0,0x6a,0,0,0,0,0,0,0,0,
-0x3c,0,0,0,0,0,0x45,0x6b,0,0x6c,0x6d,0,0,0x6d,0x6e,0,
-0,0,0,0,0,0x6f,0x70,0x71,0,0,0,0,0,0,0,0x31,
+0,0,0,0x6a,0x6b,0,0,0x6c,0,0,0,0,0,0,0,0,
+0x3d,0,0,0,0,0,0x46,0x6d,0,0x6e,0x6f,0,0,0x6f,0x70,0,
+0,0,0,0,0,0x71,0x72,0x73,0,0,0,0,0,0,0,0x32,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -265,7 +265,7 @@ const uint8_t CollationFCD::tcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0x72,0x73,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0x74,0x75,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -282,20 +282,20 @@ const uint8_t CollationFCD::tcccIndex[2048]={
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0x3e,0x74,0x75,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0x3f,0x76,0x77,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0xe,0,0,0,0,0,0,0,0,0,0,0,0,0,0
 };
 
-const uint32_t CollationFCD::tcccBits[118]={
+const uint32_t CollationFCD::tcccBits[120]={
 0,0xffffffff,0x3e7effbf,0xbe7effbf,0xfffcffff,0x7ef1ff3f,0xfff3f1f8,0x7fffff3f,0x18003,0xdfffe000,0xff31ffcf,0xcfffffff,0xfffc0,0xffff7fff,0xffff,0x1d760,
 0x1fc00,0x187c00,0x200708b,0x2000000,0x708b0000,0xc00000,0xf8,0xfccf0006,0x33ffcfc,0xfffe0000,0xbfffffff,0xb6,0x7ff0000,0x7c,0xfffff800,0x10000,
-0x9fc80005,0x3d9f,0x20000,0xffff0000,0x7ff,0xff800,0xfbc00000,0x3eef,0xe000000,0xfff00000,0xfffffffb,0x10120200,0xff1e2000,0x10000000,0xb0002000,0x10480000,
-0x4e002000,0x2000,0x30002000,0x602100,0x18000000,0x24000400,0x7000000,0xf00,0x3000000,0x2a00000,0x3d7e0000,0xdf,0x40,0x6800000,0xe0000000,0x100000,
-0x20040000,0x200,0x1800000,0x9fe00001,0x3fff0000,0x10,0xc00,0xc0040,0x800000,0xfff70000,0x31021fd,0xfbffffff,0xbffffff,0x3ffffff,0x3f3fffff,0xaaff3f3f,
-0x3fffffff,0x1fdfffff,0xefcfffde,0x1fdc7fff,0x1fff0000,0x1ffe2,0x800,0xc000000,0x4000,0xe000,0x1210,0x50,0x292,0x333e005,0x333,0xf000,
-0x3c0f,0x38000,0x80000000,0xfc00,0x55555000,0x36db02a5,0x46100000,0x47900000,0x3ff08000,0xc0000000,0x30000,0x3ffff,0x3800,0x80000,1,0xc19d0000,
-2,0x400000,0x40000f5,0x5108000,0x5f7ffc00,0x7fdb
+0x9fc80005,0x3d9f,0x20000,0xffff0000,0x7ff,0x200ff800,0xfbc00000,0x3eef,0xe000000,0xfff80000,0xfffffffb,0x10120200,0xff1e2000,0x10000000,0xb0002000,0x40000000,
+0x10480000,0x4e002000,0x2000,0x30002000,0x602100,0x18000000,0x24000400,0x7000000,0xf00,0x3000000,0x2a00000,0x3d7e0000,0xdf,0x40,0x6800000,0xe0000000,
+0x100000,0x20040000,0x200,0x1800000,0x9fe00001,0x3fff0000,0x10,0xff800,0xc00,0xc0040,0x800000,0xfff70000,0x31021fd,0xfbffffff,0xbffffff,0x3ffffff,
+0x3f3fffff,0xaaff3f3f,0x3fffffff,0x1fdfffff,0xefcfffde,0x1fdc7fff,0x1fff0000,0x1ffe2,0x800,0xc000000,0x4000,0xe000,0x1210,0x50,0x292,0x333e005,
+0x333,0xf000,0x3c0f,0x38000,0x80000000,0xfc00,0x55555000,0x36db02a5,0x46100000,0x47900000,0x3ff08000,0xc0000000,0x30000,0x3ffff,0x3800,0x80000,
+1,0xc19d0000,2,0x400000,0x40000fd,0x5108000,0x5f7ffc00,0x7fdb
 };
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/compactdecimalformat.cpp b/deps/icu-small/source/i18n/compactdecimalformat.cpp
index b2aacc45cda49c..4dd2241b23d0a6 100644
--- a/deps/icu-small/source/i18n/compactdecimalformat.cpp
+++ b/deps/icu-small/source/i18n/compactdecimalformat.cpp
@@ -1,1013 +1,75 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2018 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 1997-2015, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
-*******************************************************************************
-*
-* File COMPACTDECIMALFORMAT.CPP
-*
-********************************************************************************
-*/
+
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "charstr.h"
-#include "cstring.h"
-#include "digitlst.h"
-#include "mutex.h"
-#include "unicode/compactdecimalformat.h"
-#include "unicode/numsys.h"
-#include "unicode/plurrule.h"
-#include "unicode/ures.h"
-#include "ucln_in.h"
-#include "uhash.h"
-#include "umutex.h"
-#include "unicode/ures.h"
-#include "uresimp.h"
-
-// Maps locale name to CDFLocaleData struct.
-static UHashtable* gCompactDecimalData = NULL;
-static UMutex gCompactDecimalMetaLock = U_MUTEX_INITIALIZER;
-
-U_NAMESPACE_BEGIN
-
-static const int32_t MAX_DIGITS = 15;
-static const char gOther[] = "other";
-static const char gLatnTag[] = "latn";
-static const char gNumberElementsTag[] = "NumberElements";
-static const char gDecimalFormatTag[] = "decimalFormat";
-static const char gPatternsShort[] = "patternsShort";
-static const char gPatternsLong[] = "patternsLong";
-static const char gLatnPath[] = "NumberElements/latn";
-
-static const UChar u_0 = 0x30;
-static const UChar u_apos = 0x27;
-
-static const UChar kZero[] = {u_0};
-
-// Used to unescape single quotes.
-enum QuoteState {
-  OUTSIDE,
-  INSIDE_EMPTY,
-  INSIDE_FULL
-};
-
-enum FallbackFlags {
-  ANY = 0,
-  MUST = 1,
-  NOT_ROOT = 2
-  // Next one will be 4 then 6 etc.
-};
-
-
-// CDFUnit represents a prefix-suffix pair for a particular variant
-// and log10 value.
-struct CDFUnit : public UMemory {
-  UnicodeString prefix;
-  UnicodeString suffix;
-  inline CDFUnit() : prefix(), suffix() {
-    prefix.setToBogus();
-  }
-  inline ~CDFUnit() {}
-  inline UBool isSet() const {
-    return !prefix.isBogus();
-  }
-  inline void markAsSet() {
-    prefix.remove();
-  }
-};
-
-// CDFLocaleStyleData contains formatting data for a particular locale
-// and style.
-class CDFLocaleStyleData : public UMemory {
- public:
-  // What to divide by for each log10 value when formatting. These values
-  // will be powers of 10. For English, would be:
-  // 1, 1, 1, 1000, 1000, 1000, 1000000, 1000000, 1000000, 1000000000 ...
-  double divisors[MAX_DIGITS];
-  // Maps plural variants to CDFUnit[MAX_DIGITS] arrays.
-  // To format a number x,
-  // first compute log10(x). Compute displayNum = (x / divisors[log10(x)]).
-  // Compute the plural variant for displayNum
-  // (e.g zero, one, two, few, many, other).
-  // Compute cdfUnits = unitsByVariant[pluralVariant].
-  // Prefix and suffix to use at cdfUnits[log10(x)]
-  UHashtable* unitsByVariant;
-  // A flag for whether or not this CDFLocaleStyleData was loaded from the
-  // Latin numbering system as a fallback from the locale numbering system.
-  // This value is meaningless if the object is bogus or empty.
-  UBool fromFallback;
-  inline CDFLocaleStyleData() : unitsByVariant(NULL), fromFallback(FALSE) {
-    uprv_memset(divisors, 0, sizeof(divisors));
-  }
-  ~CDFLocaleStyleData();
-  // Init initializes this object.
-  void Init(UErrorCode& status);
-  inline UBool isBogus() const {
-    return unitsByVariant == NULL;
-  }
-  void setToBogus();
-  UBool isEmpty() {
-    return unitsByVariant == NULL || unitsByVariant->count == 0;
-  }
- private:
-  CDFLocaleStyleData(const CDFLocaleStyleData&);
-  CDFLocaleStyleData& operator=(const CDFLocaleStyleData&);
-};
-
-// CDFLocaleData contains formatting data for a particular locale.
-struct CDFLocaleData : public UMemory {
-  CDFLocaleStyleData shortData;
-  CDFLocaleStyleData longData;
-  inline CDFLocaleData() : shortData(), longData() { }
-  inline ~CDFLocaleData() { }
-  // Init initializes this object.
-  void Init(UErrorCode& status);
-};
-
-U_NAMESPACE_END
-
-U_CDECL_BEGIN
-
-static UBool U_CALLCONV cdf_cleanup(void) {
-  if (gCompactDecimalData != NULL) {
-    uhash_close(gCompactDecimalData);
-    gCompactDecimalData = NULL;
-  }
-  return TRUE;
-}
-
-static void U_CALLCONV deleteCDFUnits(void* ptr) {
-  delete [] (icu::CDFUnit*) ptr;
-}
-
-static void U_CALLCONV deleteCDFLocaleData(void* ptr) {
-  delete (icu::CDFLocaleData*) ptr;
-}
-
-U_CDECL_END
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
 
-U_NAMESPACE_BEGIN
+#include "unicode/compactdecimalformat.h"
+#include "number_mapper.h"
+#include "number_decimfmtprops.h"
 
-static UBool divisors_equal(const double* lhs, const double* rhs);
-static const CDFLocaleStyleData* getCDFLocaleStyleData(const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status);
+using namespace icu;
 
-static const CDFLocaleStyleData* extractDataByStyleEnum(const CDFLocaleData& data, UNumberCompactStyle style, UErrorCode& status);
-static CDFLocaleData* loadCDFLocaleData(const Locale& inLocale, UErrorCode& status);
-static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status);
-static int32_t populatePrefixSuffix(const char* variant, int32_t log10Value, const UnicodeString& formatStr, UHashtable* result, UBool overwrite, UErrorCode& status);
-static double calculateDivisor(double power10, int32_t numZeros);
-static UBool onlySpaces(UnicodeString u);
-static void fixQuotes(UnicodeString& s);
-static void checkForOtherVariants(CDFLocaleStyleData* result, UErrorCode& status);
-static void fillInMissing(CDFLocaleStyleData* result);
-static int32_t computeLog10(double x, UBool inRange);
-static CDFUnit* createCDFUnit(const char* variant, int32_t log10Value, UHashtable* table, UErrorCode& status);
-static const CDFUnit* getCDFUnitFallback(const UHashtable* table, const UnicodeString& variant, int32_t log10Value);
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CompactDecimalFormat)
 
-CompactDecimalFormat::CompactDecimalFormat(
-    const DecimalFormat& decimalFormat,
-    const UHashtable* unitsByVariant,
-    const double* divisors,
-    PluralRules* pluralRules)
-  : DecimalFormat(decimalFormat), _unitsByVariant(unitsByVariant), _divisors(divisors), _pluralRules(pluralRules) {
-}
-
-CompactDecimalFormat::CompactDecimalFormat(const CompactDecimalFormat& source)
-    : DecimalFormat(source), _unitsByVariant(source._unitsByVariant), _divisors(source._divisors), _pluralRules(source._pluralRules->clone()) {
-}
-
-CompactDecimalFormat* U_EXPORT2
-CompactDecimalFormat::createInstance(
-    const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status) {
-  LocalPointer<DecimalFormat> decfmt((DecimalFormat*) NumberFormat::makeInstance(inLocale, UNUM_DECIMAL, TRUE, status));
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  LocalPointer<PluralRules> pluralRules(PluralRules::forLocale(inLocale, status));
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  const CDFLocaleStyleData* data = getCDFLocaleStyleData(inLocale, style, status);
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  CompactDecimalFormat* result =
-      new CompactDecimalFormat(*decfmt, data->unitsByVariant, data->divisors, pluralRules.getAlias());
-  if (result == NULL) {
-    status = U_MEMORY_ALLOCATION_ERROR;
-    return NULL;
-  }
-  pluralRules.orphan();
-  result->setMaximumSignificantDigits(3);
-  result->setSignificantDigitsUsed(TRUE);
-  result->setGroupingUsed(FALSE);
-  return result;
-}
-
-CompactDecimalFormat&
-CompactDecimalFormat::operator=(const CompactDecimalFormat& rhs) {
-  if (this != &rhs) {
-    DecimalFormat::operator=(rhs);
-    _unitsByVariant = rhs._unitsByVariant;
-    _divisors = rhs._divisors;
-    delete _pluralRules;
-    _pluralRules = rhs._pluralRules->clone();
-  }
-  return *this;
-}
-
-CompactDecimalFormat::~CompactDecimalFormat() {
-  delete _pluralRules;
-}
-
 
-Format*
-CompactDecimalFormat::clone(void) const {
-  return new CompactDecimalFormat(*this);
+CompactDecimalFormat*
+CompactDecimalFormat::createInstance(const Locale& inLocale, UNumberCompactStyle style,
+                                     UErrorCode& status) {
+    return new CompactDecimalFormat(inLocale, style, status);
 }
 
-UBool
-CompactDecimalFormat::operator==(const Format& that) const {
-  if (this == &that) {
-    return TRUE;
-  }
-  return (DecimalFormat::operator==(that) && eqHelper((const CompactDecimalFormat&) that));
-}
-
-UBool
-CompactDecimalFormat::eqHelper(const CompactDecimalFormat& that) const {
-  return uhash_equals(_unitsByVariant, that._unitsByVariant) && divisors_equal(_divisors, that._divisors) && (*_pluralRules == *that._pluralRules);
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    double number,
-    UnicodeString& appendTo,
-    FieldPosition& pos) const {
-  UErrorCode status = U_ZERO_ERROR;
-  return format(number, appendTo, pos, status);
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    double number,
-    UnicodeString& appendTo,
-    FieldPosition& pos,
-    UErrorCode &status) const {
-  if (U_FAILURE(status)) {
-    return appendTo;
-  }
-  DigitList orig, rounded;
-  orig.set(number);
-  UBool isNegative;
-  _round(orig, rounded, isNegative, status);
-  if (U_FAILURE(status)) {
-    return appendTo;
-  }
-  double roundedDouble = rounded.getDouble();
-  if (isNegative) {
-    roundedDouble = -roundedDouble;
-  }
-  int32_t baseIdx = computeLog10(roundedDouble, TRUE);
-  double numberToFormat = roundedDouble / _divisors[baseIdx];
-  UnicodeString variant = _pluralRules->select(numberToFormat);
-  if (isNegative) {
-    numberToFormat = -numberToFormat;
-  }
-  const CDFUnit* unit = getCDFUnitFallback(_unitsByVariant, variant, baseIdx);
-  appendTo += unit->prefix;
-  DecimalFormat::format(numberToFormat, appendTo, pos);
-  appendTo += unit->suffix;
-  return appendTo;
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    double /* number */,
-    UnicodeString& appendTo,
-    FieldPositionIterator* /* posIter */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    int32_t number,
-    UnicodeString& appendTo,
-    FieldPosition& pos) const {
-  return format((double) number, appendTo, pos);
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    int32_t number,
-    UnicodeString& appendTo,
-    FieldPosition& pos,
-    UErrorCode &status) const {
-  return format((double) number, appendTo, pos, status);
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    int32_t /* number */,
-    UnicodeString& appendTo,
-    FieldPositionIterator* /* posIter */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    int64_t number,
-    UnicodeString& appendTo,
-    FieldPosition& pos) const {
-  return format((double) number, appendTo, pos);
-}
-
-UnicodeString&
-CompactDecimalFormat::format(
-    int64_t number,
-    UnicodeString& appendTo,
-    FieldPosition& pos,
-    UErrorCode &status) const {
-  return format((double) number, appendTo, pos, status);
+CompactDecimalFormat::CompactDecimalFormat(const Locale& inLocale, UNumberCompactStyle style,
+                                           UErrorCode& status)
+        : DecimalFormat(new DecimalFormatSymbols(inLocale, status), status) {
+    if (U_FAILURE(status)) return;
+    // Minimal properties: let the non-shim code path do most of the logic for us.
+    fields->properties->compactStyle = style;
+    fields->properties->groupingSize = -2; // do not forward grouping information
+    fields->properties->minimumGroupingDigits = 2;
+    touch(status);
 }
 
-UnicodeString&
-CompactDecimalFormat::format(
-    int64_t /* number */,
-    UnicodeString& appendTo,
-    FieldPositionIterator* /* posIter */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
-}
+CompactDecimalFormat::CompactDecimalFormat(const CompactDecimalFormat& source) = default;
 
-UnicodeString&
-CompactDecimalFormat::format(
-    StringPiece /* number */,
-    UnicodeString& appendTo,
-    FieldPositionIterator* /* posIter */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
-}
+CompactDecimalFormat::~CompactDecimalFormat() = default;
 
-UnicodeString&
-CompactDecimalFormat::format(
-    const DigitList& /* number */,
-    UnicodeString& appendTo,
-    FieldPositionIterator* /* posIter */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
+CompactDecimalFormat& CompactDecimalFormat::operator=(const CompactDecimalFormat& rhs) {
+    DecimalFormat::operator=(rhs);
+    return *this;
 }
 
-UnicodeString&
-CompactDecimalFormat::format(const DigitList& /* number */,
-                             UnicodeString& appendTo,
-                             FieldPosition& /* pos */,
-                             UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
-  return appendTo;
+Format* CompactDecimalFormat::clone() const {
+    return new CompactDecimalFormat(*this);
 }
 
 void
 CompactDecimalFormat::parse(
-    const UnicodeString& /* text */,
-    Formattable& /* result */,
-    ParsePosition& /* parsePosition */) const {
+        const UnicodeString& /* text */,
+        Formattable& /* result */,
+        ParsePosition& /* parsePosition */) const {
 }
 
 void
 CompactDecimalFormat::parse(
-    const UnicodeString& /* text */,
-    Formattable& /* result */,
-    UErrorCode& status) const {
-  status = U_UNSUPPORTED_ERROR;
+        const UnicodeString& /* text */,
+        Formattable& /* result */,
+        UErrorCode& status) const {
+    status = U_UNSUPPORTED_ERROR;
 }
 
 CurrencyAmount*
 CompactDecimalFormat::parseCurrency(
-    const UnicodeString& /* text */,
-    ParsePosition& /* pos */) const {
-  return NULL;
-}
-
-void CDFLocaleStyleData::Init(UErrorCode& status) {
-  if (unitsByVariant != NULL) {
-    return;
-  }
-  unitsByVariant = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
-  if (U_FAILURE(status)) {
-    return;
-  }
-  uhash_setKeyDeleter(unitsByVariant, uprv_free);
-  uhash_setValueDeleter(unitsByVariant, deleteCDFUnits);
-}
-
-CDFLocaleStyleData::~CDFLocaleStyleData() {
-  setToBogus();
-}
-
-void CDFLocaleStyleData::setToBogus() {
-  if (unitsByVariant != NULL) {
-    uhash_close(unitsByVariant);
-    unitsByVariant = NULL;
-  }
-}
-
-void CDFLocaleData::Init(UErrorCode& status) {
-  shortData.Init(status);
-  if (U_FAILURE(status)) {
-    return;
-  }
-  longData.Init(status);
-}
-
-// Helper method for operator=
-static UBool divisors_equal(const double* lhs, const double* rhs) {
-  for (int32_t i = 0; i < MAX_DIGITS; ++i) {
-    if (lhs[i] != rhs[i]) {
-      return FALSE;
-    }
-  }
-  return TRUE;
-}
-
-// getCDFLocaleStyleData returns pointer to formatting data for given locale and
-// style within the global cache. On cache miss, getCDFLocaleStyleData loads
-// the data from CLDR into the global cache before returning the pointer. If a
-// UNUM_LONG data is requested for a locale, and that locale does not have
-// UNUM_LONG data, getCDFLocaleStyleData will fall back to UNUM_SHORT data for
-// that locale.
-static const CDFLocaleStyleData* getCDFLocaleStyleData(const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status) {
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  CDFLocaleData* result = NULL;
-  const char* key = inLocale.getName();
-  {
-    Mutex lock(&gCompactDecimalMetaLock);
-    if (gCompactDecimalData == NULL) {
-      gCompactDecimalData = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &status);
-      if (U_FAILURE(status)) {
-        return NULL;
-      }
-      uhash_setKeyDeleter(gCompactDecimalData, uprv_free);
-      uhash_setValueDeleter(gCompactDecimalData, deleteCDFLocaleData);
-      ucln_i18n_registerCleanup(UCLN_I18N_CDFINFO, cdf_cleanup);
-    } else {
-      result = (CDFLocaleData*) uhash_get(gCompactDecimalData, key);
-    }
-  }
-  if (result != NULL) {
-    return extractDataByStyleEnum(*result, style, status);
-  }
-
-  result = loadCDFLocaleData(inLocale, status);
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-
-  {
-    Mutex lock(&gCompactDecimalMetaLock);
-    CDFLocaleData* temp = (CDFLocaleData*) uhash_get(gCompactDecimalData, key);
-    if (temp != NULL) {
-      delete result;
-      result = temp;
-    } else {
-      uhash_put(gCompactDecimalData, uprv_strdup(key), (void*) result, &status);
-      if (U_FAILURE(status)) {
-        return NULL;
-      }
-    }
-  }
-  return extractDataByStyleEnum(*result, style, status);
-}
-
-static const CDFLocaleStyleData* extractDataByStyleEnum(const CDFLocaleData& data, UNumberCompactStyle style, UErrorCode& status) {
-  switch (style) {
-    case UNUM_SHORT:
-      return &data.shortData;
-    case UNUM_LONG:
-      if (!data.longData.isBogus()) {
-        return &data.longData;
-      }
-      return &data.shortData;
-    default:
-      status = U_ILLEGAL_ARGUMENT_ERROR;
-      return NULL;
-  }
-}
-
-// loadCDFLocaleData loads formatting data from CLDR for a given locale. The
-// caller owns the returned pointer.
-static CDFLocaleData* loadCDFLocaleData(const Locale& inLocale, UErrorCode& status) {
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  CDFLocaleData* result = new CDFLocaleData;
-  if (result == NULL) {
-    status = U_MEMORY_ALLOCATION_ERROR;
-    return NULL;
-  }
-  result->Init(status);
-  if (U_FAILURE(status)) {
-    delete result;
-    return NULL;
-  }
-
-  load(inLocale, result, status);
-
-  if (U_FAILURE(status)) {
-    delete result;
-    return NULL;
-  }
-  return result;
-}
-
-namespace {
-
-struct CmptDecDataSink : public ResourceSink {
-
-  CDFLocaleData& dataBundle; // Where to save values when they are read
-  UBool isLatin; // Whether or not we are traversing the Latin tree
-  UBool isFallback; // Whether or not we are traversing the Latin tree as fallback
-
-  enum EPatternsTableKey { PATTERNS_SHORT, PATTERNS_LONG };
-  enum EFormatsTableKey { DECIMAL_FORMAT, CURRENCY_FORMAT };
-
-  /*
-   * NumberElements{              <-- top (numbering system table)
-   *  latn{                       <-- patternsTable (one per numbering system)
-   *    patternsLong{             <-- formatsTable (one per pattern)
-   *      decimalFormat{          <-- powersOfTenTable (one per format)
-   *        1000{                 <-- pluralVariantsTable (one per power of ten)
-   *          one{"0 thousand"}   <-- plural variant and template
-   */
-
-  CmptDecDataSink(CDFLocaleData& _dataBundle)
-    : dataBundle(_dataBundle), isLatin(FALSE), isFallback(FALSE) {}
-  virtual ~CmptDecDataSink();
-
-  virtual void put(const char *key, ResourceValue &value, UBool isRoot, UErrorCode &errorCode) {
-    // SPECIAL CASE: Don't consume root in the non-Latin numbering system
-    if (isRoot && !isLatin) { return; }
-
-    ResourceTable patternsTable = value.getTable(errorCode);
-    if (U_FAILURE(errorCode)) { return; }
-    for (int i1 = 0; patternsTable.getKeyAndValue(i1, key, value); ++i1) {
-
-      // Check for patternsShort or patternsLong
-      EPatternsTableKey patternsTableKey;
-      if (uprv_strcmp(key, gPatternsShort) == 0) {
-        patternsTableKey = PATTERNS_SHORT;
-      } else if (uprv_strcmp(key, gPatternsLong) == 0) {
-        patternsTableKey = PATTERNS_LONG;
-      } else {
-        continue;
-      }
-
-      // Traverse into the formats table
-      ResourceTable formatsTable = value.getTable(errorCode);
-      if (U_FAILURE(errorCode)) { return; }
-      for (int i2 = 0; formatsTable.getKeyAndValue(i2, key, value); ++i2) {
-
-        // Check for decimalFormat or currencyFormat
-        EFormatsTableKey formatsTableKey;
-        if (uprv_strcmp(key, gDecimalFormatTag) == 0) {
-          formatsTableKey = DECIMAL_FORMAT;
-        // TODO: Enable this statement when currency support is added
-        // } else if (uprv_strcmp(key, gCurrencyFormat) == 0) {
-        //   formatsTableKey = CURRENCY_FORMAT;
-        } else {
-          continue;
-        }
-
-        // Set the current style and destination based on the two keys
-        UNumberCompactStyle style;
-        CDFLocaleStyleData* destination = NULL;
-        if (patternsTableKey == PATTERNS_LONG
-            && formatsTableKey == DECIMAL_FORMAT) {
-          style = UNUM_LONG;
-          destination = &dataBundle.longData;
-        } else if (patternsTableKey == PATTERNS_SHORT
-            && formatsTableKey == DECIMAL_FORMAT) {
-          style = UNUM_SHORT;
-          destination = &dataBundle.shortData;
-        // TODO: Enable the following statements when currency support is added
-        // } else if (patternsTableKey == PATTERNS_SHORT
-        //     && formatsTableKey == CURRENCY_FORMAT) {
-        //   style = UNUM_SHORT_CURRENCY; // or whatever the enum gets named
-        //   destination = &dataBundle.shortCurrencyData;
-        // } else {
-        //   // Silently ignore this case
-        //   continue;
-        }
-
-        // SPECIAL CASE: RULES FOR WHETHER OR NOT TO CONSUME THIS TABLE:
-        //   1) Don't consume longData if shortData was consumed from the non-Latin
-        //      locale numbering system
-        //   2) Don't consume longData for the first time if this is the root bundle and
-        //      shortData is already populated from a more specific locale. Note that if
-        //      both longData and shortData are both only in root, longData will be
-        //      consumed since it is alphabetically before shortData in the bundle.
-        if (isFallback
-                && style == UNUM_LONG
-                && !dataBundle.shortData.isEmpty()
-                && !dataBundle.shortData.fromFallback) {
-            continue;
-        }
-        if (isRoot
-                && style == UNUM_LONG
-                && dataBundle.longData.isEmpty()
-                && !dataBundle.shortData.isEmpty()) {
-            continue;
-        }
-
-        // Set the "fromFallback" flag on the data object
-        destination->fromFallback = isFallback;
-
-        // Traverse into the powers of ten table
-        ResourceTable powersOfTenTable = value.getTable(errorCode);
-        if (U_FAILURE(errorCode)) { return; }
-        for (int i3 = 0; powersOfTenTable.getKeyAndValue(i3, key, value); ++i3) {
-
-          // The key will always be some even power of 10. e.g 10000.
-          char* endPtr = NULL;
-          double power10 = uprv_strtod(key, &endPtr);
-          if (*endPtr != 0) {
-            errorCode = U_INTERNAL_PROGRAM_ERROR;
-            return;
-          }
-          int32_t log10Value = computeLog10(power10, FALSE);
-
-          // Silently ignore divisors that are too big.
-          if (log10Value >= MAX_DIGITS) continue;
-
-          // Iterate over the plural variants ("one", "other", etc)
-          ResourceTable pluralVariantsTable = value.getTable(errorCode);
-          if (U_FAILURE(errorCode)) { return; }
-          for (int i4 = 0; pluralVariantsTable.getKeyAndValue(i4, key, value); ++i4) {
-            const char* pluralVariant = key;
-            const UnicodeString formatStr = value.getUnicodeString(errorCode);
-
-            // Copy the data into the in-memory data bundle (do not overwrite
-            // existing values)
-            int32_t numZeros = populatePrefixSuffix(
-                pluralVariant, log10Value, formatStr,
-                destination->unitsByVariant, FALSE, errorCode);
-
-            // If populatePrefixSuffix returns -1, it means that this key has been
-            // encountered already.
-            if (numZeros < 0) {
-              continue;
-            }
-
-            // Set the divisor, which is based on the number of zeros in the template
-            // string.  If the divisor from here is different from the one previously
-            // stored, it means that the number of zeros in different plural variants
-            // differs; throw an exception.
-            // TODO: How should I check for floating-point errors here?
-            //       Is there a good reason why "divisor" is double and not long like Java?
-            double divisor = calculateDivisor(power10, numZeros);
-            if (destination->divisors[log10Value] != 0.0
-                && destination->divisors[log10Value] != divisor) {
-              errorCode = U_INTERNAL_PROGRAM_ERROR;
-              return;
-            }
-            destination->divisors[log10Value] = divisor;
-          }
-        }
-      }
-    }
-  }
-};
-
-// Virtual destructors must be defined out of line.
-CmptDecDataSink::~CmptDecDataSink() {}
-
-} // namespace
-
-static void load(const Locale& inLocale, CDFLocaleData* result, UErrorCode& status) {
-  LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(inLocale, status));
-  if (U_FAILURE(status)) {
-    return;
-  }
-  const char* nsName = ns->getName();
-
-  LocalUResourceBundlePointer resource(ures_open(NULL, inLocale.getName(), &status));
-  if (U_FAILURE(status)) {
-    return;
-  }
-  CmptDecDataSink sink(*result);
-  sink.isFallback = FALSE;
-
-  // First load the number elements data if nsName is not Latin.
-  if (uprv_strcmp(nsName, gLatnTag) != 0) {
-    sink.isLatin = FALSE;
-    CharString path;
-    path.append(gNumberElementsTag, status)
-        .append('/', status)
-        .append(nsName, status);
-    ures_getAllItemsWithFallback(resource.getAlias(), path.data(), sink, status);
-    if (status == U_MISSING_RESOURCE_ERROR) {
-      // Silently ignore and use Latin
-      status = U_ZERO_ERROR;
-    } else if  (U_FAILURE(status)) {
-      return;
-    }
-    sink.isFallback = TRUE;
-  }
-
-  // Now load Latin.
-  sink.isLatin = TRUE;
-  ures_getAllItemsWithFallback(resource.getAlias(), gLatnPath, sink, status);
-  if (U_FAILURE(status)) return;
-
-  // If longData is empty, default it to be equal to shortData
-  if (result->longData.isEmpty()) {
-    result->longData.setToBogus();
-  }
-
-  // Check for "other" variants in each of the three data classes, and resolve missing elements.
-
-  if (!result->longData.isBogus()) {
-    checkForOtherVariants(&result->longData, status);
-    if (U_FAILURE(status)) return;
-    fillInMissing(&result->longData);
-  }
-
-  checkForOtherVariants(&result->shortData, status);
-  if (U_FAILURE(status)) return;
-  fillInMissing(&result->shortData);
-
-  // TODO: Enable this statement when currency support is added
-  // checkForOtherVariants(&result->shortCurrencyData, status);
-  // if (U_FAILURE(status)) return;
-  // fillInMissing(&result->shortCurrencyData);
-}
-
-// populatePrefixSuffix Adds a specific prefix-suffix pair to result for a
-// given variant and log10 value.
-// variant is 'zero', 'one', 'two', 'few', 'many', or 'other'.
-// formatStr is the format string from which the prefix and suffix are
-// extracted. It is usually of form 'Pefix 000 suffix'.
-// populatePrefixSuffix returns the number of 0's found in formatStr
-// before the decimal point.
-// In the special case that formatStr contains only spaces for prefix
-// and suffix, populatePrefixSuffix returns log10Value + 1.
-static int32_t populatePrefixSuffix(
-    const char* variant, int32_t log10Value, const UnicodeString& formatStr, UHashtable* result, UBool overwrite, UErrorCode& status) {
-  if (U_FAILURE(status)) {
-    return 0;
-  }
-
-  // ICU 59 HACK: Ignore negative part of format string, mimicking ICU 58 behavior.
-  // TODO(sffc): Make sure this is fixed during the overhaul port in ICU 60.
-  int32_t semiPos = formatStr.indexOf(';', 0);
-  if (semiPos == -1) {
-    semiPos = formatStr.length();
-  }
-  UnicodeString positivePart = formatStr.tempSubString(0, semiPos);
-
-  int32_t firstIdx = positivePart.indexOf(kZero, UPRV_LENGTHOF(kZero), 0);
-  // We must have 0's in format string.
-  if (firstIdx == -1) {
-    status = U_INTERNAL_PROGRAM_ERROR;
-    return 0;
-  }
-  int32_t lastIdx = positivePart.lastIndexOf(kZero, UPRV_LENGTHOF(kZero), firstIdx);
-  CDFUnit* unit = createCDFUnit(variant, log10Value, result, status);
-  if (U_FAILURE(status)) {
-    return 0;
-  }
-
-  // Return -1 if we are not overwriting an existing value
-  if (unit->isSet() && !overwrite) {
-    return -1;
-  }
-  unit->markAsSet();
-
-  // Everything up to first 0 is the prefix
-  unit->prefix = positivePart.tempSubString(0, firstIdx);
-  fixQuotes(unit->prefix);
-  // Everything beyond the last 0 is the suffix
-  unit->suffix = positivePart.tempSubString(lastIdx + 1);
-  fixQuotes(unit->suffix);
-
-  // If there is effectively no prefix or suffix, ignore the actual number of
-  // 0's and act as if the number of 0's matches the size of the number.
-  if (onlySpaces(unit->prefix) && onlySpaces(unit->suffix)) {
-    return log10Value + 1;
-  }
-
-  // Calculate number of zeros before decimal point
-  int32_t idx = firstIdx + 1;
-  while (idx <= lastIdx && positivePart.charAt(idx) == u_0) {
-    ++idx;
-  }
-  return (idx - firstIdx);
-}
-
-// Calculate a divisor based on the magnitude and number of zeros in the
-// template string.
-static double calculateDivisor(double power10, int32_t numZeros) {
-  double divisor = power10;
-  for (int32_t i = 1; i < numZeros; ++i) {
-    divisor /= 10.0;
-  }
-  return divisor;
-}
-
-static UBool onlySpaces(UnicodeString u) {
-  return u.trim().length() == 0;
+        const UnicodeString& /* text */,
+        ParsePosition& /* pos */) const {
+    return nullptr;
 }
 
-// fixQuotes unescapes single quotes. Don''t -> Don't. Letter 'j' -> Letter j.
-// Modifies s in place.
-static void fixQuotes(UnicodeString& s) {
-  QuoteState state = OUTSIDE;
-  int32_t len = s.length();
-  int32_t dest = 0;
-  for (int32_t i = 0; i < len; ++i) {
-    UChar ch = s.charAt(i);
-    if (ch == u_apos) {
-      if (state == INSIDE_EMPTY) {
-        s.setCharAt(dest, ch);
-        ++dest;
-      }
-    } else {
-      s.setCharAt(dest, ch);
-      ++dest;
-    }
-
-    // Update state
-    switch (state) {
-      case OUTSIDE:
-        state = ch == u_apos ? INSIDE_EMPTY : OUTSIDE;
-        break;
-      case INSIDE_EMPTY:
-      case INSIDE_FULL:
-        state = ch == u_apos ? OUTSIDE : INSIDE_FULL;
-        break;
-      default:
-        break;
-    }
-  }
-  s.truncate(dest);
-}
-
-// Checks to make sure that an "other" variant is present in all
-// powers of 10.
-static void checkForOtherVariants(CDFLocaleStyleData* result,
-    UErrorCode& status) {
-  if (result == NULL || result->unitsByVariant == NULL) {
-    return;
-  }
-
-  const CDFUnit* otherByBase =
-      (const CDFUnit*) uhash_get(result->unitsByVariant, gOther);
-  if (otherByBase == NULL) {
-    status = U_INTERNAL_PROGRAM_ERROR;
-    return;
-  }
-
-  // Check all other plural variants, and make sure that if
-  // any of them are populated, then other is also populated
-  int32_t pos = UHASH_FIRST;
-  const UHashElement* element;
-  while ((element = uhash_nextElement(result->unitsByVariant, &pos)) != NULL) {
-    CDFUnit* variantsByBase = (CDFUnit*) element->value.pointer;
-    if (variantsByBase == otherByBase) continue;
-    for (int32_t log10Value = 0; log10Value < MAX_DIGITS; ++log10Value) {
-      if (variantsByBase[log10Value].isSet()
-          && !otherByBase[log10Value].isSet()) {
-        status = U_INTERNAL_PROGRAM_ERROR;
-        return;
-      }
-    }
-  }
-}
-
-// fillInMissing ensures that the data in result is complete.
-// result data is complete if for each variant in result, there exists
-// a prefix-suffix pair for each log10 value and there also exists
-// a divisor for each log10 value.
-//
-// First this function figures out for which log10 values, the other
-// variant already had data. These are the same log10 values defined
-// in CLDR.
-//
-// For each log10 value not defined in CLDR, it uses the divisor for
-// the last defined log10 value or 1.
-//
-// Then for each variant, it does the following. For each log10
-// value not defined in CLDR, copy the prefix-suffix pair from the
-// previous log10 value. If log10 value is defined in CLDR but is
-// missing from given variant, copy the prefix-suffix pair for that
-// log10 value from the 'other' variant.
-static void fillInMissing(CDFLocaleStyleData* result) {
-  const CDFUnit* otherUnits =
-      (const CDFUnit*) uhash_get(result->unitsByVariant, gOther);
-  UBool definedInCLDR[MAX_DIGITS];
-  double lastDivisor = 1.0;
-  for (int32_t i = 0; i < MAX_DIGITS; ++i) {
-    if (!otherUnits[i].isSet()) {
-      result->divisors[i] = lastDivisor;
-      definedInCLDR[i] = FALSE;
-    } else {
-      lastDivisor = result->divisors[i];
-      definedInCLDR[i] = TRUE;
-    }
-  }
-  // Iterate over each variant.
-  int32_t pos = UHASH_FIRST;
-  const UHashElement* element = uhash_nextElement(result->unitsByVariant, &pos);
-  for (;element != NULL; element = uhash_nextElement(result->unitsByVariant, &pos)) {
-    CDFUnit* units = (CDFUnit*) element->value.pointer;
-    for (int32_t i = 0; i < MAX_DIGITS; ++i) {
-      if (definedInCLDR[i]) {
-        if (!units[i].isSet()) {
-          units[i] = otherUnits[i];
-        }
-      } else {
-        if (i == 0) {
-          units[0].markAsSet();
-        } else {
-          units[i] = units[i - 1];
-        }
-      }
-    }
-  }
-}
-
-// computeLog10 computes floor(log10(x)). If inRange is TRUE, the biggest
-// value computeLog10 will return MAX_DIGITS -1 even for
-// numbers > 10^MAX_DIGITS. If inRange is FALSE, computeLog10 will return
-// up to MAX_DIGITS.
-static int32_t computeLog10(double x, UBool inRange) {
-  int32_t result = 0;
-  int32_t max = inRange ? MAX_DIGITS - 1 : MAX_DIGITS;
-  while (x >= 10.0) {
-    x /= 10.0;
-    ++result;
-    if (result == max) {
-      break;
-    }
-  }
-  return result;
-}
-
-// createCDFUnit returns a pointer to the prefix-suffix pair for a given
-// variant and log10 value within table. If no such prefix-suffix pair is
-// stored in table, one is created within table before returning pointer.
-static CDFUnit* createCDFUnit(const char* variant, int32_t log10Value, UHashtable* table, UErrorCode& status) {
-  if (U_FAILURE(status)) {
-    return NULL;
-  }
-  CDFUnit *cdfUnit = (CDFUnit*) uhash_get(table, variant);
-  if (cdfUnit == NULL) {
-    cdfUnit = new CDFUnit[MAX_DIGITS];
-    if (cdfUnit == NULL) {
-      status = U_MEMORY_ALLOCATION_ERROR;
-      return NULL;
-    }
-    uhash_put(table, uprv_strdup(variant), cdfUnit, &status);
-    if (U_FAILURE(status)) {
-      return NULL;
-    }
-  }
-  CDFUnit* result = &cdfUnit[log10Value];
-  return result;
-}
-
-// getCDFUnitFallback returns a pointer to the prefix-suffix pair for a given
-// variant and log10 value within table. If the given variant doesn't exist, it
-// falls back to the OTHER variant. Therefore, this method will always return
-// some non-NULL value.
-static const CDFUnit* getCDFUnitFallback(const UHashtable* table, const UnicodeString& variant, int32_t log10Value) {
-  CharString cvariant;
-  UErrorCode status = U_ZERO_ERROR;
-  const CDFUnit *cdfUnit = NULL;
-  cvariant.appendInvariantChars(variant, status);
-  if (!U_FAILURE(status)) {
-    cdfUnit = (const CDFUnit*) uhash_get(table, cvariant.data());
-  }
-  if (cdfUnit == NULL) {
-    cdfUnit = (const CDFUnit*) uhash_get(table, gOther);
-  }
-  return &cdfUnit[log10Value];
-}
 
-U_NAMESPACE_END
-#endif
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/currpinf.cpp b/deps/icu-small/source/i18n/currpinf.cpp
index 5d3ca620891500..6b1efd5f4da721 100644
--- a/deps/icu-small/source/i18n/currpinf.cpp
+++ b/deps/icu-small/source/i18n/currpinf.cpp
@@ -203,6 +203,9 @@ CurrencyPluralInfo::setCurrencyPluralPattern(const UnicodeString& pluralCount,
                                              const UnicodeString& pattern,
                                              UErrorCode& status) {
     if (U_SUCCESS(status)) {
+        UnicodeString* oldValue = static_cast<UnicodeString*>(
+            fPluralCountToCurrencyUnitPattern->get(pluralCount));
+        delete oldValue;
         fPluralCountToCurrencyUnitPattern->put(pluralCount, new UnicodeString(pattern), status);
     }
 }
diff --git a/deps/icu-small/source/i18n/currunit.cpp b/deps/icu-small/source/i18n/currunit.cpp
index 83429c01694acc..6d8d1cd6c6f97f 100644
--- a/deps/icu-small/source/i18n/currunit.cpp
+++ b/deps/icu-small/source/i18n/currunit.cpp
@@ -17,21 +17,32 @@
 #include "unicode/currunit.h"
 #include "unicode/ustring.h"
 #include "cstring.h"
+#include "uinvchar.h"
+
+static constexpr char16_t kDefaultCurrency[] = u"XXX";
 
 U_NAMESPACE_BEGIN
 
 CurrencyUnit::CurrencyUnit(ConstChar16Ptr _isoCode, UErrorCode& ec) {
-    *isoCode = 0;
-    if (U_SUCCESS(ec)) {
-        if (_isoCode != nullptr && u_strlen(_isoCode)==3) {
-            u_strcpy(isoCode, _isoCode);
-            char simpleIsoCode[4];
-            u_UCharsToChars(isoCode, simpleIsoCode, 4);
-            initCurrency(simpleIsoCode);
-        } else {
-            ec = U_ILLEGAL_ARGUMENT_ERROR;
-        }
+    // The constructor always leaves the CurrencyUnit in a valid state (with a 3-character currency code).
+    // Note: in ICU4J Currency.getInstance(), we check string length for 3, but in ICU4C we allow a
+    // non-NUL-terminated string to be passed as an argument, so it is not possible to check length.
+    const char16_t* isoCodeToUse;
+    if (U_FAILURE(ec) || _isoCode == nullptr) {
+        isoCodeToUse = kDefaultCurrency;
+    } else if (!uprv_isInvariantUString(_isoCode, 3)) {
+        // TODO: Perform a more strict ASCII check like in ICU4J isAlpha3Code?
+        isoCodeToUse = kDefaultCurrency;
+        ec = U_INVARIANT_CONVERSION_ERROR;
+    } else {
+        isoCodeToUse = _isoCode;
     }
+    // TODO: Perform uppercasing here like in ICU4J Currency.getInstance()?
+    uprv_memcpy(isoCode, isoCodeToUse, sizeof(UChar) * 3);
+    isoCode[3] = 0;
+    char simpleIsoCode[4];
+    u_UCharsToChars(isoCode, simpleIsoCode, 4);
+    initCurrency(simpleIsoCode);
 }
 
 CurrencyUnit::CurrencyUnit(const CurrencyUnit& other) : MeasureUnit(other) {
@@ -52,7 +63,7 @@ CurrencyUnit::CurrencyUnit(const MeasureUnit& other, UErrorCode& ec) : MeasureUn
 }
 
 CurrencyUnit::CurrencyUnit() : MeasureUnit() {
-    u_strcpy(isoCode, u"XXX");
+    u_strcpy(isoCode, kDefaultCurrency);
     char simpleIsoCode[4];
     u_UCharsToChars(isoCode, simpleIsoCode, 4);
     initCurrency(simpleIsoCode);
diff --git a/deps/icu-small/source/i18n/dcfmtimp.h b/deps/icu-small/source/i18n/dcfmtimp.h
deleted file mode 100644
index e582efb344b3b8..00000000000000
--- a/deps/icu-small/source/i18n/dcfmtimp.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-********************************************************************************
-*   Copyright (C) 2012-2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-********************************************************************************/
-
-#ifndef DCFMTIMP_H
-#define DCFMTIMP_H
-
-#include "unicode/utypes.h"
-
-
-#if UCONFIG_FORMAT_FASTPATHS_49
-
-U_NAMESPACE_BEGIN
-
-enum EDecimalFormatFastpathStatus {
-  kFastpathNO = 0,
-  kFastpathYES = 1,
-  kFastpathUNKNOWN = 2, /* not yet set */
-  kFastpathMAYBE = 3 /* depends on value being formatted. */
-};
-
-/**
- * Must be smaller than DecimalFormat::fReserved
- */
-struct DecimalFormatInternal {
-  uint8_t    fFastFormatStatus;
-  uint8_t    fFastParseStatus;
-
-  DecimalFormatInternal &operator=(const DecimalFormatInternal& rhs) {
-    fFastParseStatus = rhs.fFastParseStatus;
-    fFastFormatStatus = rhs.fFastFormatStatus;
-    return *this;
-  }
-#ifdef FMT_DEBUG
-  void dump() const {
-    printf("DecimalFormatInternal: fFastFormatStatus=%c, fFastParseStatus=%c\n",
-           "NY?"[(int)fFastFormatStatus&3],
-           "NY?"[(int)fFastParseStatus&3]
-           );
-  }
-#endif
-};
-
-
-
-U_NAMESPACE_END
-
-#endif
-
-#endif
diff --git a/deps/icu-small/source/i18n/dcfmtsym.cpp b/deps/icu-small/source/i18n/dcfmtsym.cpp
index 680c3120a1e0f9..5a432aec8e4df0 100644
--- a/deps/icu-small/source/i18n/dcfmtsym.cpp
+++ b/deps/icu-small/source/i18n/dcfmtsym.cpp
@@ -66,7 +66,7 @@ static const UChar INTL_CURRENCY_SYMBOL_STR[] = {0xa4, 0xa4, 0};
 static const char *gNumberElementKeys[DecimalFormatSymbols::kFormatSymbolCount] = {
     "decimal",
     "group",
-    "list",
+    NULL, /* #11897: the <list> symbol is NOT the pattern separator symbol */
     "percentSign",
     NULL, /* Native zero digit is deprecated from CLDR - get it from the numbering system */
     NULL, /* Pattern digit character is deprecated from CLDR - use # by default always */
@@ -98,7 +98,7 @@ static const char *gNumberElementKeys[DecimalFormatSymbols::kFormatSymbolCount]
 // Initializes this with the decimal format symbols in the default locale.
 
 DecimalFormatSymbols::DecimalFormatSymbols(UErrorCode& status)
-        : UObject(), locale() {
+        : UObject(), locale(), currPattern(NULL) {
     initialize(locale, status, TRUE);
 }
 
@@ -106,12 +106,12 @@ DecimalFormatSymbols::DecimalFormatSymbols(UErrorCode& status)
 // Initializes this with the decimal format symbols in the desired locale.
 
 DecimalFormatSymbols::DecimalFormatSymbols(const Locale& loc, UErrorCode& status)
-        : UObject(), locale(loc) {
+        : UObject(), locale(loc), currPattern(NULL) {
     initialize(locale, status);
 }
 
 DecimalFormatSymbols::DecimalFormatSymbols(const Locale& loc, const NumberingSystem& ns, UErrorCode& status)
-        : UObject(), locale(loc) {
+        : UObject(), locale(loc), currPattern(NULL) {
     initialize(locale, status, FALSE, &ns);
 }
 
@@ -349,7 +349,6 @@ DecimalFormatSymbols::initialize(const Locale& loc, UErrorCode& status,
 {
     if (U_FAILURE(status)) { return; }
     *validLocale = *actualLocale = 0;
-    currPattern = NULL;
 
     // First initialize all the symbols to the fallbacks for anything we can't find
     initialize();
@@ -477,6 +476,7 @@ DecimalFormatSymbols::initialize(const Locale& loc, UErrorCode& status,
     UErrorCode localStatus = U_ZERO_ERROR;
     uccLen = ucurr_forLocale(locName, ucc, uccLen, &localStatus);
 
+    // TODO: Currency pattern data loading is duplicated in number_formatimpl.cpp
     if(U_SUCCESS(localStatus) && uccLen > 0) {
         char cc[4]={0};
         u_UCharsToChars(ucc, cc, uccLen);
diff --git a/deps/icu-small/source/i18n/decfmtst.cpp b/deps/icu-small/source/i18n/decfmtst.cpp
deleted file mode 100644
index 5943affad4eb06..00000000000000
--- a/deps/icu-small/source/i18n/decfmtst.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2009-2016, International Business Machines Corporation and
-* others. All Rights Reserved.
-*******************************************************************************
-*
-* This file contains the class DecimalFormatStaticSets
-*
-* DecimalFormatStaticSets holds the UnicodeSets that are needed for lenient
-* parsing of decimal and group separators.
-********************************************************************************
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/unistr.h"
-#include "unicode/uniset.h"
-#include "unicode/uchar.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "uassert.h"
-#include "ucln_in.h"
-#include "umutex.h"
-
-#include "decfmtst.h"
-
-U_NAMESPACE_BEGIN
-
-
-//------------------------------------------------------------------------------
-//
-// Unicode Set pattern strings for all of the required constant sets.
-//               Initialized with hex values for portability to EBCDIC based machines.
-//                Really ugly, but there's no good way to avoid it.
-//
-//------------------------------------------------------------------------------
-
-static const UChar gDotEquivalentsPattern[] = {
-        // [       .    \u2024  \u3002  \uFE12  \uFE52  \uFF0E  \uFF61     ]
-        0x005B, 0x002E, 0x2024, 0x3002, 0xFE12, 0xFE52, 0xFF0E, 0xFF61, 0x005D, 0x0000};
-
-static const UChar gCommaEquivalentsPattern[] = {
-        // [       ,    \u060C  \u066B  \u3001  \uFE10  \uFE11  \uFE50  \uFE51  \uFF0C  \uFF64    ]
-        0x005B, 0x002C, 0x060C, 0x066B, 0x3001, 0xFE10, 0xFE11, 0xFE50, 0xFE51, 0xFF0C, 0xFF64, 0x005D, 0x0000};
-
-static const UChar gOtherGroupingSeparatorsPattern[] = {
-        // [       \     SPACE     '      NBSP  \u066C  \u2000     -    \u200A  \u2018  \u2019  \u202F  \u205F  \u3000  \uFF07     ]
-        0x005B, 0x005C, 0x0020, 0x0027, 0x00A0, 0x066C, 0x2000, 0x002D, 0x200A, 0x2018, 0x2019, 0x202F, 0x205F, 0x3000, 0xFF07, 0x005D, 0x0000};
-
-static const UChar gDashEquivalentsPattern[] = {
-        // [       \      -     HYPHEN  F_DASH  N_DASH   MINUS     ]
-        0x005B, 0x005C, 0x002D, 0x2010, 0x2012, 0x2013, 0x2212, 0x005D, 0x0000};
-
-static const UChar gStrictDotEquivalentsPattern[] = {
-        // [      .     \u2024  \uFE52  \uFF0E  \uFF61    ]
-        0x005B, 0x002E, 0x2024, 0xFE52, 0xFF0E, 0xFF61, 0x005D, 0x0000};
-
-static const UChar gStrictCommaEquivalentsPattern[] = {
-        // [       ,    \u066B  \uFE10  \uFE50  \uFF0C     ]
-        0x005B, 0x002C, 0x066B, 0xFE10, 0xFE50, 0xFF0C, 0x005D, 0x0000};
-
-static const UChar gStrictOtherGroupingSeparatorsPattern[] = {
-        // [       \     SPACE     '      NBSP  \u066C  \u2000     -    \u200A  \u2018  \u2019  \u202F  \u205F  \u3000  \uFF07     ]
-        0x005B, 0x005C, 0x0020, 0x0027, 0x00A0, 0x066C, 0x2000, 0x002D, 0x200A, 0x2018, 0x2019, 0x202F, 0x205F, 0x3000, 0xFF07, 0x005D, 0x0000};
-
-static const UChar gStrictDashEquivalentsPattern[] = {
-        // [       \      -      MINUS     ]
-        0x005B, 0x005C, 0x002D, 0x2212, 0x005D, 0x0000};
-
-static const UChar32 gMinusSigns[] = {
-    0x002D,
-    0x207B,
-    0x208B,
-    0x2212,
-    0x2796,
-    0xFE63,
-    0xFF0D};
-
-static const UChar32 gPlusSigns[] = {
-    0x002B,
-    0x207A,
-    0x208A,
-    0x2795,
-    0xfB29,
-    0xFE62,
-    0xFF0B};
-
-static void initUnicodeSet(const UChar32 *raw, int32_t len, UnicodeSet *s) {
-    for (int32_t i = 0; i < len; ++i) {
-        s->add(raw[i]);
-    }
-}
-
-DecimalFormatStaticSets::DecimalFormatStaticSets(UErrorCode &status)
-: fDotEquivalents(NULL),
-  fCommaEquivalents(NULL),
-  fOtherGroupingSeparators(NULL),
-  fDashEquivalents(NULL),
-  fStrictDotEquivalents(NULL),
-  fStrictCommaEquivalents(NULL),
-  fStrictOtherGroupingSeparators(NULL),
-  fStrictDashEquivalents(NULL),
-  fDefaultGroupingSeparators(NULL),
-  fStrictDefaultGroupingSeparators(NULL),
-  fMinusSigns(NULL),
-  fPlusSigns(NULL)
-{
-    fDotEquivalents                = new UnicodeSet(UnicodeString(TRUE, gDotEquivalentsPattern, -1),                status);
-    fCommaEquivalents              = new UnicodeSet(UnicodeString(TRUE, gCommaEquivalentsPattern, -1),              status);
-    fOtherGroupingSeparators       = new UnicodeSet(UnicodeString(TRUE, gOtherGroupingSeparatorsPattern, -1),       status);
-    fDashEquivalents               = new UnicodeSet(UnicodeString(TRUE, gDashEquivalentsPattern, -1),               status);
-
-    fStrictDotEquivalents          = new UnicodeSet(UnicodeString(TRUE, gStrictDotEquivalentsPattern, -1),          status);
-    fStrictCommaEquivalents        = new UnicodeSet(UnicodeString(TRUE, gStrictCommaEquivalentsPattern, -1),        status);
-    fStrictOtherGroupingSeparators = new UnicodeSet(UnicodeString(TRUE, gStrictOtherGroupingSeparatorsPattern, -1), status);
-    fStrictDashEquivalents         = new UnicodeSet(UnicodeString(TRUE, gStrictDashEquivalentsPattern, -1),         status);
-
-
-    fDefaultGroupingSeparators = new UnicodeSet(*fDotEquivalents);
-    fDefaultGroupingSeparators->addAll(*fCommaEquivalents);
-    fDefaultGroupingSeparators->addAll(*fOtherGroupingSeparators);
-
-    fStrictDefaultGroupingSeparators = new UnicodeSet(*fStrictDotEquivalents);
-    fStrictDefaultGroupingSeparators->addAll(*fStrictCommaEquivalents);
-    fStrictDefaultGroupingSeparators->addAll(*fStrictOtherGroupingSeparators);
-
-    fMinusSigns = new UnicodeSet();
-    fPlusSigns = new UnicodeSet();
-
-    // Check for null pointers
-    if (fDotEquivalents == NULL || fCommaEquivalents == NULL || fOtherGroupingSeparators == NULL || fDashEquivalents == NULL ||
-        fStrictDotEquivalents == NULL || fStrictCommaEquivalents == NULL || fStrictOtherGroupingSeparators == NULL || fStrictDashEquivalents == NULL ||
-        fDefaultGroupingSeparators == NULL || fStrictOtherGroupingSeparators == NULL ||
-        fMinusSigns == NULL || fPlusSigns == NULL) {
-      cleanup();
-      status = U_MEMORY_ALLOCATION_ERROR;
-      return;
-    }
-
-    initUnicodeSet(
-            gMinusSigns,
-            UPRV_LENGTHOF(gMinusSigns),
-            fMinusSigns);
-    initUnicodeSet(
-            gPlusSigns,
-            UPRV_LENGTHOF(gPlusSigns),
-            fPlusSigns);
-
-    // Freeze all the sets
-    fDotEquivalents->freeze();
-    fCommaEquivalents->freeze();
-    fOtherGroupingSeparators->freeze();
-    fDashEquivalents->freeze();
-    fStrictDotEquivalents->freeze();
-    fStrictCommaEquivalents->freeze();
-    fStrictOtherGroupingSeparators->freeze();
-    fStrictDashEquivalents->freeze();
-    fDefaultGroupingSeparators->freeze();
-    fStrictDefaultGroupingSeparators->freeze();
-    fMinusSigns->freeze();
-    fPlusSigns->freeze();
-}
-
-DecimalFormatStaticSets::~DecimalFormatStaticSets() {
-  cleanup();
-}
-
-void DecimalFormatStaticSets::cleanup() { // Be sure to clean up newly added fields!
-    delete fDotEquivalents; fDotEquivalents = NULL;
-    delete fCommaEquivalents; fCommaEquivalents = NULL;
-    delete fOtherGroupingSeparators; fOtherGroupingSeparators = NULL;
-    delete fDashEquivalents; fDashEquivalents = NULL;
-    delete fStrictDotEquivalents; fStrictDotEquivalents = NULL;
-    delete fStrictCommaEquivalents; fStrictCommaEquivalents = NULL;
-    delete fStrictOtherGroupingSeparators; fStrictOtherGroupingSeparators = NULL;
-    delete fStrictDashEquivalents; fStrictDashEquivalents = NULL;
-    delete fDefaultGroupingSeparators; fDefaultGroupingSeparators = NULL;
-    delete fStrictDefaultGroupingSeparators; fStrictDefaultGroupingSeparators = NULL;
-    delete fStrictOtherGroupingSeparators; fStrictOtherGroupingSeparators = NULL;
-    delete fMinusSigns; fMinusSigns = NULL;
-    delete fPlusSigns; fPlusSigns = NULL;
-}
-
-static DecimalFormatStaticSets *gStaticSets;
-static icu::UInitOnce gStaticSetsInitOnce = U_INITONCE_INITIALIZER;
-
-
-//------------------------------------------------------------------------------
-//
-//   decfmt_cleanup     Memory cleanup function, free/delete all
-//                      cached memory.  Called by ICU's u_cleanup() function.
-//
-//------------------------------------------------------------------------------
-U_CDECL_BEGIN
-static UBool U_CALLCONV
-decimfmt_cleanup(void)
-{
-    delete gStaticSets;
-    gStaticSets = NULL;
-    gStaticSetsInitOnce.reset();
-    return TRUE;
-}
-
-static void U_CALLCONV initSets(UErrorCode &status) {
-    U_ASSERT(gStaticSets == NULL);
-    ucln_i18n_registerCleanup(UCLN_I18N_DECFMT, decimfmt_cleanup);
-    gStaticSets = new DecimalFormatStaticSets(status);
-    if (U_FAILURE(status)) {
-        delete gStaticSets;
-        gStaticSets = NULL;
-        return;
-    }
-    if (gStaticSets == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
-}
-U_CDECL_END
-
-const DecimalFormatStaticSets *DecimalFormatStaticSets::getStaticSets(UErrorCode &status) {
-    umtx_initOnce(gStaticSetsInitOnce, initSets, status);
-    return gStaticSets;
-}
-
-
-const UnicodeSet *DecimalFormatStaticSets::getSimilarDecimals(UChar32 decimal, UBool strictParse)
-{
-    UErrorCode status = U_ZERO_ERROR;
-    umtx_initOnce(gStaticSetsInitOnce, initSets, status);
-    if (U_FAILURE(status)) {
-        return NULL;
-    }
-
-    if (gStaticSets->fDotEquivalents->contains(decimal)) {
-        return strictParse ? gStaticSets->fStrictDotEquivalents : gStaticSets->fDotEquivalents;
-    }
-
-    if (gStaticSets->fCommaEquivalents->contains(decimal)) {
-        return strictParse ? gStaticSets->fStrictCommaEquivalents : gStaticSets->fCommaEquivalents;
-    }
-
-    // if there is no match, return NULL
-    return NULL;
-}
-
-
-U_NAMESPACE_END
-#endif   // !UCONFIG_NO_FORMATTING
diff --git a/deps/icu-small/source/i18n/decfmtst.h b/deps/icu-small/source/i18n/decfmtst.h
deleted file mode 100644
index 63ae50c6df904a..00000000000000
--- a/deps/icu-small/source/i18n/decfmtst.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2009-2016, International Business Machines Corporation and
-* others. All Rights Reserved.
-*******************************************************************************
-*
-* This file contains declarations for the class DecimalFormatStaticSets
-*
-* DecimalFormatStaticSets holds the UnicodeSets that are needed for lenient
-* parsing of decimal and group separators.
-********************************************************************************
-*/
-
-#ifndef DECFMTST_H
-#define DECFMTST_H
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/uobject.h"
-
-U_NAMESPACE_BEGIN
-
-class  UnicodeSet;
-
-
-class DecimalFormatStaticSets : public UMemory
-{
-public:
-    // Constructor and Destructor not for general use.
-    //   Public to permit access from plain C implementation functions.
-    DecimalFormatStaticSets(UErrorCode &status);
-    ~DecimalFormatStaticSets();
-
-    /**
-      * Return a pointer to a lazy-initialized singleton instance of this class.
-      */
-    static const DecimalFormatStaticSets *getStaticSets(UErrorCode &status);
-
-    static const UnicodeSet *getSimilarDecimals(UChar32 decimal, UBool strictParse);
-
-    UnicodeSet *fDotEquivalents;
-    UnicodeSet *fCommaEquivalents;
-    UnicodeSet *fOtherGroupingSeparators;
-    UnicodeSet *fDashEquivalents;
-
-    UnicodeSet *fStrictDotEquivalents;
-    UnicodeSet *fStrictCommaEquivalents;
-    UnicodeSet *fStrictOtherGroupingSeparators;
-    UnicodeSet *fStrictDashEquivalents;
-
-    UnicodeSet *fDefaultGroupingSeparators;
-    UnicodeSet *fStrictDefaultGroupingSeparators;
-
-    UnicodeSet *fMinusSigns;
-    UnicodeSet *fPlusSigns;
-private:
-    void cleanup();
-
-};
-
-
-U_NAMESPACE_END
-
-#endif   // !UCONFIG_NO_FORMATTING
-#endif   // DECFMTST_H
diff --git a/deps/icu-small/source/i18n/decimalformatpattern.cpp b/deps/icu-small/source/i18n/decimalformatpattern.cpp
deleted file mode 100644
index 80a1870f33ef8d..00000000000000
--- a/deps/icu-small/source/i18n/decimalformatpattern.cpp
+++ /dev/null
@@ -1,656 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 1997-2015, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
-*******************************************************************************
-*/
-
-#include "uassert.h"
-#include "decimalformatpattern.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/dcfmtsym.h"
-#include "unicode/format.h"
-#include "unicode/utf16.h"
-#include "decimalformatpatternimpl.h"
-
-
-#ifdef FMT_DEBUG
-#define debug(x) printf("%s:%d: %s\n", __FILE__,__LINE__, x);
-#else
-#define debug(x)
-#endif
-
-U_NAMESPACE_BEGIN
-
-// TODO: Travis Keep: Copied from numfmt.cpp
-static int32_t kDoubleIntegerDigits  = 309;
-static int32_t kDoubleFractionDigits = 340;
-
-
-// TODO: Travis Keep: Copied from numfmt.cpp
-static int32_t gDefaultMaxIntegerDigits = 2000000000;
-
-// TODO: Travis Keep: This function was copied from format.cpp
-static void syntaxError(const UnicodeString& pattern,
-                         int32_t pos,
-                         UParseError& parseError) {
-    parseError.offset = pos;
-    parseError.line=0;  // we are not using line number
-
-    // for pre-context
-    int32_t start = (pos < U_PARSE_CONTEXT_LEN)? 0 : (pos - (U_PARSE_CONTEXT_LEN-1
-                                                             /* subtract 1 so that we have room for null*/));
-    int32_t stop  = pos;
-    pattern.extract(start,stop-start,parseError.preContext,0);
-    //null terminate the buffer
-    parseError.preContext[stop-start] = 0;
-
-    //for post-context
-    start = pattern.moveIndex32(pos, 1);
-    stop = pos + U_PARSE_CONTEXT_LEN - 1;
-    if (stop > pattern.length()) {
-        stop = pattern.length();
-    }
-    pattern.extract(start, stop - start, parseError.postContext, 0);
-    //null terminate the buffer
-    parseError.postContext[stop-start]= 0;
-}
-
-DecimalFormatPattern::DecimalFormatPattern()
-        : fMinimumIntegerDigits(1),
-          fMaximumIntegerDigits(gDefaultMaxIntegerDigits),
-          fMinimumFractionDigits(0),
-          fMaximumFractionDigits(3),
-          fUseSignificantDigits(FALSE),
-          fMinimumSignificantDigits(1),
-          fMaximumSignificantDigits(6),
-          fUseExponentialNotation(FALSE),
-          fMinExponentDigits(0),
-          fExponentSignAlwaysShown(FALSE),
-          fCurrencySignCount(fgCurrencySignCountZero),
-          fGroupingUsed(TRUE),
-          fGroupingSize(0),
-          fGroupingSize2(0),
-          fMultiplier(1),
-          fDecimalSeparatorAlwaysShown(FALSE),
-          fFormatWidth(0),
-          fRoundingIncrementUsed(FALSE),
-          fRoundingIncrement(),
-          fPad(kDefaultPad),
-          fNegPatternsBogus(TRUE),
-          fPosPatternsBogus(TRUE),
-          fNegPrefixPattern(),
-          fNegSuffixPattern(),
-          fPosPrefixPattern(),
-          fPosSuffixPattern(),
-          fPadPosition(DecimalFormatPattern::kPadBeforePrefix) {
-}
-
-
-DecimalFormatPatternParser::DecimalFormatPatternParser() :
-    fZeroDigit(kPatternZeroDigit),
-    fSigDigit(kPatternSignificantDigit),
-    fGroupingSeparator((UChar)kPatternGroupingSeparator),
-    fDecimalSeparator((UChar)kPatternDecimalSeparator),
-    fPercent((UChar)kPatternPercent),
-    fPerMill((UChar)kPatternPerMill),
-    fDigit((UChar)kPatternDigit),
-    fSeparator((UChar)kPatternSeparator),
-    fExponent((UChar)kPatternExponent),
-    fPlus((UChar)kPatternPlus),
-    fMinus((UChar)kPatternMinus),
-    fPadEscape((UChar)kPatternPadEscape) {
-}
-
-void DecimalFormatPatternParser::useSymbols(
-        const DecimalFormatSymbols& symbols) {
-    fZeroDigit = symbols.getConstSymbol(
-            DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
-    fSigDigit = symbols.getConstSymbol(
-            DecimalFormatSymbols::kSignificantDigitSymbol).char32At(0);
-    fGroupingSeparator = symbols.getConstSymbol(
-            DecimalFormatSymbols::kGroupingSeparatorSymbol);
-    fDecimalSeparator = symbols.getConstSymbol(
-            DecimalFormatSymbols::kDecimalSeparatorSymbol);
-    fPercent = symbols.getConstSymbol(
-            DecimalFormatSymbols::kPercentSymbol);
-    fPerMill = symbols.getConstSymbol(
-            DecimalFormatSymbols::kPerMillSymbol);
-    fDigit = symbols.getConstSymbol(
-            DecimalFormatSymbols::kDigitSymbol);
-    fSeparator = symbols.getConstSymbol(
-            DecimalFormatSymbols::kPatternSeparatorSymbol);
-    fExponent = symbols.getConstSymbol(
-            DecimalFormatSymbols::kExponentialSymbol);
-    fPlus = symbols.getConstSymbol(
-            DecimalFormatSymbols::kPlusSignSymbol);
-    fMinus = symbols.getConstSymbol(
-            DecimalFormatSymbols::kMinusSignSymbol);
-    fPadEscape = symbols.getConstSymbol(
-            DecimalFormatSymbols::kPadEscapeSymbol);
-}
-
-void
-DecimalFormatPatternParser::applyPatternWithoutExpandAffix(
-        const UnicodeString& pattern,
-        DecimalFormatPattern& out,
-        UParseError& parseError,
-        UErrorCode& status) {
-    if (U_FAILURE(status))
-    {
-        return;
-    }
-    out = DecimalFormatPattern();
-
-    // Clear error struct
-    parseError.offset = -1;
-    parseError.preContext[0] = parseError.postContext[0] = (UChar)0;
-
-    // TODO: Travis Keep: This won't always work.
-    UChar nineDigit = (UChar)(fZeroDigit + 9);
-    int32_t digitLen = fDigit.length();
-    int32_t groupSepLen = fGroupingSeparator.length();
-    int32_t decimalSepLen = fDecimalSeparator.length();
-
-    int32_t pos = 0;
-    int32_t patLen = pattern.length();
-    // Part 0 is the positive pattern.  Part 1, if present, is the negative
-    // pattern.
-    for (int32_t part=0; part<2 && pos<patLen; ++part) {
-        // The subpart ranges from 0 to 4: 0=pattern proper, 1=prefix,
-        // 2=suffix, 3=prefix in quote, 4=suffix in quote.  Subpart 0 is
-        // between the prefix and suffix, and consists of pattern
-        // characters.  In the prefix and suffix, percent, perMill, and
-        // currency symbols are recognized and translated.
-        int32_t subpart = 1, sub0Start = 0, sub0Limit = 0, sub2Limit = 0;
-
-        // It's important that we don't change any fields of this object
-        // prematurely.  We set the following variables for the multiplier,
-        // grouping, etc., and then only change the actual object fields if
-        // everything parses correctly.  This also lets us register
-        // the data from part 0 and ignore the part 1, except for the
-        // prefix and suffix.
-        UnicodeString prefix;
-        UnicodeString suffix;
-        int32_t decimalPos = -1;
-        int32_t multiplier = 1;
-        int32_t digitLeftCount = 0, zeroDigitCount = 0, digitRightCount = 0, sigDigitCount = 0;
-        int8_t groupingCount = -1;
-        int8_t groupingCount2 = -1;
-        int32_t padPos = -1;
-        UChar32 padChar = 0;
-        int32_t roundingPos = -1;
-        DigitList roundingInc;
-        int8_t expDigits = -1;
-        UBool expSignAlways = FALSE;
-
-        // The affix is either the prefix or the suffix.
-        UnicodeString* affix = &prefix;
-
-        int32_t start = pos;
-        UBool isPartDone = FALSE;
-        UChar32 ch;
-
-        for (; !isPartDone && pos < patLen; ) {
-            // Todo: account for surrogate pairs
-            ch = pattern.char32At(pos);
-            switch (subpart) {
-            case 0: // Pattern proper subpart (between prefix & suffix)
-                // Process the digits, decimal, and grouping characters.  We
-                // record five pieces of information.  We expect the digits
-                // to occur in the pattern ####00.00####, and we record the
-                // number of left digits, zero (central) digits, and right
-                // digits.  The position of the last grouping character is
-                // recorded (should be somewhere within the first two blocks
-                // of characters), as is the position of the decimal point,
-                // if any (should be in the zero digits).  If there is no
-                // decimal point, then there should be no right digits.
-                if (pattern.compare(pos, digitLen, fDigit) == 0) {
-                    if (zeroDigitCount > 0 || sigDigitCount > 0) {
-                        ++digitRightCount;
-                    } else {
-                        ++digitLeftCount;
-                    }
-                    if (groupingCount >= 0 && decimalPos < 0) {
-                        ++groupingCount;
-                    }
-                    pos += digitLen;
-                } else if ((ch >= fZeroDigit && ch <= nineDigit) ||
-                           ch == fSigDigit) {
-                    if (digitRightCount > 0) {
-                        // Unexpected '0'
-                        debug("Unexpected '0'")
-                        status = U_UNEXPECTED_TOKEN;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    if (ch == fSigDigit) {
-                        ++sigDigitCount;
-                    } else {
-                        if (ch != fZeroDigit && roundingPos < 0) {
-                            roundingPos = digitLeftCount + zeroDigitCount;
-                        }
-                        if (roundingPos >= 0) {
-                            roundingInc.append((char)(ch - fZeroDigit + '0'));
-                        }
-                        ++zeroDigitCount;
-                    }
-                    if (groupingCount >= 0 && decimalPos < 0) {
-                        ++groupingCount;
-                    }
-                    pos += U16_LENGTH(ch);
-                } else if (pattern.compare(pos, groupSepLen, fGroupingSeparator) == 0) {
-                    if (decimalPos >= 0) {
-                        // Grouping separator after decimal
-                        debug("Grouping separator after decimal")
-                        status = U_UNEXPECTED_TOKEN;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    groupingCount2 = groupingCount;
-                    groupingCount = 0;
-                    pos += groupSepLen;
-                } else if (pattern.compare(pos, decimalSepLen, fDecimalSeparator) == 0) {
-                    if (decimalPos >= 0) {
-                        // Multiple decimal separators
-                        debug("Multiple decimal separators")
-                        status = U_MULTIPLE_DECIMAL_SEPARATORS;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    // Intentionally incorporate the digitRightCount,
-                    // even though it is illegal for this to be > 0
-                    // at this point.  We check pattern syntax below.
-                    decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
-                    pos += decimalSepLen;
-                } else {
-                    if (pattern.compare(pos, fExponent.length(), fExponent) == 0) {
-                        if (expDigits >= 0) {
-                            // Multiple exponential symbols
-                            debug("Multiple exponential symbols")
-                            status = U_MULTIPLE_EXPONENTIAL_SYMBOLS;
-                            syntaxError(pattern,pos,parseError);
-                            return;
-                        }
-                        if (groupingCount >= 0) {
-                            // Grouping separator in exponential pattern
-                            debug("Grouping separator in exponential pattern")
-                            status = U_MALFORMED_EXPONENTIAL_PATTERN;
-                            syntaxError(pattern,pos,parseError);
-                            return;
-                        }
-                        pos += fExponent.length();
-                        // Check for positive prefix
-                        if (pos < patLen
-                            && pattern.compare(pos, fPlus.length(), fPlus) == 0) {
-                            expSignAlways = TRUE;
-                            pos += fPlus.length();
-                        }
-                        // Use lookahead to parse out the exponential part of the
-                        // pattern, then jump into suffix subpart.
-                        expDigits = 0;
-                        while (pos < patLen &&
-                               pattern.char32At(pos) == fZeroDigit) {
-                            ++expDigits;
-                            pos += U16_LENGTH(fZeroDigit);
-                        }
-
-                        // 1. Require at least one mantissa pattern digit
-                        // 2. Disallow "#+ @" in mantissa
-                        // 3. Require at least one exponent pattern digit
-                        if (((digitLeftCount + zeroDigitCount) < 1 &&
-                             (sigDigitCount + digitRightCount) < 1) ||
-                            (sigDigitCount > 0 && digitLeftCount > 0) ||
-                            expDigits < 1) {
-                            // Malformed exponential pattern
-                            debug("Malformed exponential pattern")
-                            status = U_MALFORMED_EXPONENTIAL_PATTERN;
-                            syntaxError(pattern,pos,parseError);
-                            return;
-                        }
-                    }
-                    // Transition to suffix subpart
-                    subpart = 2; // suffix subpart
-                    affix = &suffix;
-                    sub0Limit = pos;
-                    continue;
-                }
-                break;
-            case 1: // Prefix subpart
-            case 2: // Suffix subpart
-                // Process the prefix / suffix characters
-                // Process unquoted characters seen in prefix or suffix
-                // subpart.
-
-                // Several syntax characters implicitly begins the
-                // next subpart if we are in the prefix; otherwise
-                // they are illegal if unquoted.
-                if (!pattern.compare(pos, digitLen, fDigit) ||
-                    !pattern.compare(pos, groupSepLen, fGroupingSeparator) ||
-                    !pattern.compare(pos, decimalSepLen, fDecimalSeparator) ||
-                    (ch >= fZeroDigit && ch <= nineDigit) ||
-                    ch == fSigDigit) {
-                    if (subpart == 1) { // prefix subpart
-                        subpart = 0; // pattern proper subpart
-                        sub0Start = pos; // Reprocess this character
-                        continue;
-                    } else {
-                        status = U_UNQUOTED_SPECIAL;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                } else if (ch == kCurrencySign) {
-                    affix->append(kQuote); // Encode currency
-                    // Use lookahead to determine if the currency sign is
-                    // doubled or not.
-                    U_ASSERT(U16_LENGTH(kCurrencySign) == 1);
-                    if ((pos+1) < pattern.length() && pattern[pos+1] == kCurrencySign) {
-                        affix->append(kCurrencySign);
-                        ++pos; // Skip over the doubled character
-                        if ((pos+1) < pattern.length() &&
-                            pattern[pos+1] == kCurrencySign) {
-                            affix->append(kCurrencySign);
-                            ++pos; // Skip over the doubled character
-                            out.fCurrencySignCount = fgCurrencySignCountInPluralFormat;
-                        } else {
-                            out.fCurrencySignCount = fgCurrencySignCountInISOFormat;
-                        }
-                    } else {
-                        out.fCurrencySignCount = fgCurrencySignCountInSymbolFormat;
-                    }
-                    // Fall through to append(ch)
-                } else if (ch == kQuote) {
-                    // A quote outside quotes indicates either the opening
-                    // quote or two quotes, which is a quote literal.  That is,
-                    // we have the first quote in 'do' or o''clock.
-                    U_ASSERT(U16_LENGTH(kQuote) == 1);
-                    ++pos;
-                    if (pos < pattern.length() && pattern[pos] == kQuote) {
-                        affix->append(kQuote); // Encode quote
-                        // Fall through to append(ch)
-                    } else {
-                        subpart += 2; // open quote
-                        continue;
-                    }
-                } else if (pattern.compare(pos, fSeparator.length(), fSeparator) == 0) {
-                    // Don't allow separators in the prefix, and don't allow
-                    // separators in the second pattern (part == 1).
-                    if (subpart == 1 || part == 1) {
-                        // Unexpected separator
-                        debug("Unexpected separator")
-                        status = U_UNEXPECTED_TOKEN;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    sub2Limit = pos;
-                    isPartDone = TRUE; // Go to next part
-                    pos += fSeparator.length();
-                    break;
-                } else if (pattern.compare(pos, fPercent.length(), fPercent) == 0) {
-                    // Next handle characters which are appended directly.
-                    if (multiplier != 1) {
-                        // Too many percent/perMill characters
-                        debug("Too many percent characters")
-                        status = U_MULTIPLE_PERCENT_SYMBOLS;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    affix->append(kQuote); // Encode percent/perMill
-                    affix->append(kPatternPercent); // Use unlocalized pattern char
-                    multiplier = 100;
-                    pos += fPercent.length();
-                    break;
-                } else if (pattern.compare(pos, fPerMill.length(), fPerMill) == 0) {
-                    // Next handle characters which are appended directly.
-                    if (multiplier != 1) {
-                        // Too many percent/perMill characters
-                        debug("Too many perMill characters")
-                        status = U_MULTIPLE_PERMILL_SYMBOLS;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    affix->append(kQuote); // Encode percent/perMill
-                    affix->append(kPatternPerMill); // Use unlocalized pattern char
-                    multiplier = 1000;
-                    pos += fPerMill.length();
-                    break;
-                } else if (pattern.compare(pos, fPadEscape.length(), fPadEscape) == 0) {
-                    if (padPos >= 0 ||               // Multiple pad specifiers
-                        (pos+1) == pattern.length()) { // Nothing after padEscape
-                        debug("Multiple pad specifiers")
-                        status = U_MULTIPLE_PAD_SPECIFIERS;
-                        syntaxError(pattern,pos,parseError);
-                        return;
-                    }
-                    padPos = pos;
-                    pos += fPadEscape.length();
-                    padChar = pattern.char32At(pos);
-                    pos += U16_LENGTH(padChar);
-                    break;
-                } else if (pattern.compare(pos, fMinus.length(), fMinus) == 0) {
-                    affix->append(kQuote); // Encode minus
-                    affix->append(kPatternMinus);
-                    pos += fMinus.length();
-                    break;
-                } else if (pattern.compare(pos, fPlus.length(), fPlus) == 0) {
-                    affix->append(kQuote); // Encode plus
-                    affix->append(kPatternPlus);
-                    pos += fPlus.length();
-                    break;
-                }
-                // Unquoted, non-special characters fall through to here, as
-                // well as other code which needs to append something to the
-                // affix.
-                affix->append(ch);
-                pos += U16_LENGTH(ch);
-                break;
-            case 3: // Prefix subpart, in quote
-            case 4: // Suffix subpart, in quote
-                // A quote within quotes indicates either the closing
-                // quote or two quotes, which is a quote literal.  That is,
-                // we have the second quote in 'do' or 'don''t'.
-                if (ch == kQuote) {
-                    ++pos;
-                    if (pos < pattern.length() && pattern[pos] == kQuote) {
-                        affix->append(kQuote); // Encode quote
-                        // Fall through to append(ch)
-                    } else {
-                        subpart -= 2; // close quote
-                        continue;
-                    }
-                }
-                affix->append(ch);
-                pos += U16_LENGTH(ch);
-                break;
-            }
-        }
-
-        if (sub0Limit == 0) {
-            sub0Limit = pattern.length();
-        }
-
-        if (sub2Limit == 0) {
-            sub2Limit = pattern.length();
-        }
-
-        /* Handle patterns with no '0' pattern character.  These patterns
-         * are legal, but must be recodified to make sense.  "##.###" ->
-         * "#0.###".  ".###" -> ".0##".
-         *
-         * We allow patterns of the form "####" to produce a zeroDigitCount
-         * of zero (got that?); although this seems like it might make it
-         * possible for format() to produce empty strings, format() checks
-         * for this condition and outputs a zero digit in this situation.
-         * Having a zeroDigitCount of zero yields a minimum integer digits
-         * of zero, which allows proper round-trip patterns.  We don't want
-         * "#" to become "#0" when toPattern() is called (even though that's
-         * what it really is, semantically).
-         */
-        if (zeroDigitCount == 0 && sigDigitCount == 0 &&
-            digitLeftCount > 0 && decimalPos >= 0) {
-            // Handle "###.###" and "###." and ".###"
-            int n = decimalPos;
-            if (n == 0)
-                ++n; // Handle ".###"
-            digitRightCount = digitLeftCount - n;
-            digitLeftCount = n - 1;
-            zeroDigitCount = 1;
-        }
-
-        // Do syntax checking on the digits, decimal points, and quotes.
-        if ((decimalPos < 0 && digitRightCount > 0 && sigDigitCount == 0) ||
-            (decimalPos >= 0 &&
-             (sigDigitCount > 0 ||
-              decimalPos < digitLeftCount ||
-              decimalPos > (digitLeftCount + zeroDigitCount))) ||
-            groupingCount == 0 || groupingCount2 == 0 ||
-            (sigDigitCount > 0 && zeroDigitCount > 0) ||
-            subpart > 2)
-        { // subpart > 2 == unmatched quote
-            debug("Syntax error")
-            status = U_PATTERN_SYNTAX_ERROR;
-            syntaxError(pattern,pos,parseError);
-            return;
-        }
-
-        // Make sure pad is at legal position before or after affix.
-        if (padPos >= 0) {
-            if (padPos == start) {
-                padPos = DecimalFormatPattern::kPadBeforePrefix;
-            } else if (padPos+2 == sub0Start) {
-                padPos = DecimalFormatPattern::kPadAfterPrefix;
-            } else if (padPos == sub0Limit) {
-                padPos = DecimalFormatPattern::kPadBeforeSuffix;
-            } else if (padPos+2 == sub2Limit) {
-                padPos = DecimalFormatPattern::kPadAfterSuffix;
-            } else {
-                // Illegal pad position
-                debug("Illegal pad position")
-                status = U_ILLEGAL_PAD_POSITION;
-                syntaxError(pattern,pos,parseError);
-                return;
-            }
-        }
-
-        if (part == 0) {
-            out.fPosPatternsBogus = FALSE;
-            out.fPosPrefixPattern = prefix;
-            out.fPosSuffixPattern = suffix;
-            out.fNegPatternsBogus = TRUE;
-            out.fNegPrefixPattern.remove();
-            out.fNegSuffixPattern.remove();
-
-            out.fUseExponentialNotation = (expDigits >= 0);
-            if (out.fUseExponentialNotation) {
-              out.fMinExponentDigits = expDigits;
-            }
-            out.fExponentSignAlwaysShown = expSignAlways;
-            int32_t digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
-            // The effectiveDecimalPos is the position the decimal is at or
-            // would be at if there is no decimal.  Note that if
-            // decimalPos<0, then digitTotalCount == digitLeftCount +
-            // zeroDigitCount.
-            int32_t effectiveDecimalPos = decimalPos >= 0 ? decimalPos : digitTotalCount;
-            UBool isSigDig = (sigDigitCount > 0);
-            out.fUseSignificantDigits = isSigDig;
-            if (isSigDig) {
-                out.fMinimumSignificantDigits = sigDigitCount;
-                out.fMaximumSignificantDigits = sigDigitCount + digitRightCount;
-            } else {
-                int32_t minInt = effectiveDecimalPos - digitLeftCount;
-                out.fMinimumIntegerDigits = minInt;
-                out.fMaximumIntegerDigits = out.fUseExponentialNotation
-                    ? digitLeftCount + out.fMinimumIntegerDigits
-                    : gDefaultMaxIntegerDigits;
-                out.fMaximumFractionDigits = decimalPos >= 0
-                    ? (digitTotalCount - decimalPos) : 0;
-                out.fMinimumFractionDigits = decimalPos >= 0
-                    ? (digitLeftCount + zeroDigitCount - decimalPos) : 0;
-            }
-            out.fGroupingUsed = groupingCount > 0;
-            out.fGroupingSize = (groupingCount > 0) ? groupingCount : 0;
-            out.fGroupingSize2 = (groupingCount2 > 0 && groupingCount2 != groupingCount)
-                ? groupingCount2 : 0;
-            out.fMultiplier = multiplier;
-            out.fDecimalSeparatorAlwaysShown = decimalPos == 0
-                    || decimalPos == digitTotalCount;
-            if (padPos >= 0) {
-                out.fPadPosition = (DecimalFormatPattern::EPadPosition) padPos;
-                // To compute the format width, first set up sub0Limit -
-                // sub0Start.  Add in prefix/suffix length later.
-
-                // fFormatWidth = prefix.length() + suffix.length() +
-                //    sub0Limit - sub0Start;
-                out.fFormatWidth = sub0Limit - sub0Start;
-                out.fPad = padChar;
-            } else {
-                out.fFormatWidth = 0;
-            }
-            if (roundingPos >= 0) {
-                out.fRoundingIncrementUsed = TRUE;
-                roundingInc.setDecimalAt(effectiveDecimalPos - roundingPos);
-                out.fRoundingIncrement = roundingInc;
-            } else {
-                out.fRoundingIncrementUsed = FALSE;
-            }
-        } else {
-            out.fNegPatternsBogus = FALSE;
-            out.fNegPrefixPattern = prefix;
-            out.fNegSuffixPattern = suffix;
-        }
-    }
-
-    if (pattern.length() == 0) {
-        out.fNegPatternsBogus = TRUE;
-        out.fNegPrefixPattern.remove();
-        out.fNegSuffixPattern.remove();
-        out.fPosPatternsBogus = FALSE;
-        out.fPosPrefixPattern.remove();
-        out.fPosSuffixPattern.remove();
-
-        out.fMinimumIntegerDigits = 0;
-        out.fMaximumIntegerDigits = kDoubleIntegerDigits;
-        out.fMinimumFractionDigits = 0;
-        out.fMaximumFractionDigits = kDoubleFractionDigits;
-
-        out.fUseExponentialNotation = FALSE;
-        out.fCurrencySignCount = fgCurrencySignCountZero;
-        out.fGroupingUsed = FALSE;
-        out.fGroupingSize = 0;
-        out.fGroupingSize2 = 0;
-        out.fMultiplier = 1;
-        out.fDecimalSeparatorAlwaysShown = FALSE;
-        out.fFormatWidth = 0;
-        out.fRoundingIncrementUsed = FALSE;
-    }
-
-    // If there was no negative pattern, or if the negative pattern is
-    // identical to the positive pattern, then prepend the minus sign to the
-    // positive pattern to form the negative pattern.
-    if (out.fNegPatternsBogus ||
-        (out.fNegPrefixPattern == out.fPosPrefixPattern
-         && out.fNegSuffixPattern == out.fPosSuffixPattern)) {
-        out.fNegPatternsBogus = FALSE;
-        out.fNegSuffixPattern = out.fPosSuffixPattern;
-        out.fNegPrefixPattern.remove();
-        out.fNegPrefixPattern.append(kQuote).append(kPatternMinus)
-            .append(out.fPosPrefixPattern);
-    }
-    // TODO: Deprecate/Remove out.fNegSuffixPattern and 3 other fields.
-    AffixPattern::parseAffixString(
-            out.fNegSuffixPattern, out.fNegSuffixAffix, status);
-    AffixPattern::parseAffixString(
-            out.fPosSuffixPattern, out.fPosSuffixAffix, status);
-    AffixPattern::parseAffixString(
-            out.fNegPrefixPattern, out.fNegPrefixAffix, status);
-    AffixPattern::parseAffixString(
-            out.fPosPrefixPattern, out.fPosPrefixAffix, status);
-}
-
-U_NAMESPACE_END
-
-#endif /* !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/decimalformatpattern.h b/deps/icu-small/source/i18n/decimalformatpattern.h
deleted file mode 100644
index 1c297575ead1e7..00000000000000
--- a/deps/icu-small/source/i18n/decimalformatpattern.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 1997-2015, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
-*******************************************************************************
-*/
-#ifndef _DECIMAL_FORMAT_PATTERN
-#define _DECIMAL_FORMAT_PATTERN
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/uobject.h"
-#include "unicode/unistr.h"
-#include "digitlst.h"
-#include "affixpatternparser.h"
-
-U_NAMESPACE_BEGIN
-
-// currency sign count
-enum CurrencySignCount {
-    fgCurrencySignCountZero,
-    fgCurrencySignCountInSymbolFormat,
-    fgCurrencySignCountInISOFormat,
-    fgCurrencySignCountInPluralFormat
-};
-
-class DecimalFormatSymbols;
-
-struct DecimalFormatPattern : public UMemory {
-  enum EPadPosition {
-      kPadBeforePrefix,
-      kPadAfterPrefix,
-      kPadBeforeSuffix,
-      kPadAfterSuffix
-  };
-
-  DecimalFormatPattern();
-
-  int32_t fMinimumIntegerDigits;
-  int32_t fMaximumIntegerDigits;
-  int32_t fMinimumFractionDigits;
-  int32_t fMaximumFractionDigits;
-  UBool fUseSignificantDigits;
-  int32_t fMinimumSignificantDigits;
-  int32_t fMaximumSignificantDigits;
-  UBool fUseExponentialNotation;
-  int32_t fMinExponentDigits;
-  UBool fExponentSignAlwaysShown;
-  int32_t fCurrencySignCount;
-  UBool fGroupingUsed;
-  int32_t fGroupingSize;
-  int32_t fGroupingSize2;
-  int32_t fMultiplier;
-  UBool fDecimalSeparatorAlwaysShown;
-  int32_t fFormatWidth;
-  UBool fRoundingIncrementUsed;
-  DigitList fRoundingIncrement;
-  UChar32 fPad;
-  UBool fNegPatternsBogus;
-  UBool fPosPatternsBogus;
-  UnicodeString fNegPrefixPattern;
-  UnicodeString fNegSuffixPattern;
-  UnicodeString fPosPrefixPattern;
-  UnicodeString fPosSuffixPattern;
-  AffixPattern fNegPrefixAffix;
-  AffixPattern fNegSuffixAffix;
-  AffixPattern fPosPrefixAffix;
-  AffixPattern fPosSuffixAffix;
-  EPadPosition fPadPosition;
-};
-
-class DecimalFormatPatternParser : public UMemory {
-  public:
-    DecimalFormatPatternParser();
-    void useSymbols(const DecimalFormatSymbols& symbols);
-
-    void applyPatternWithoutExpandAffix(
-        const UnicodeString& pattern,
-        DecimalFormatPattern& out,
-        UParseError& parseError,
-        UErrorCode& status);
-  private:
-    DecimalFormatPatternParser(const DecimalFormatPatternParser&);
-    DecimalFormatPatternParser& operator=(DecimalFormatPatternParser& rhs);
-    UChar32 fZeroDigit;
-    UChar32 fSigDigit;
-    UnicodeString fGroupingSeparator;
-    UnicodeString fDecimalSeparator;
-    UnicodeString fPercent;
-    UnicodeString fPerMill;
-    UnicodeString fDigit;
-    UnicodeString fSeparator;
-    UnicodeString fExponent;
-    UnicodeString fPlus;
-    UnicodeString fMinus;
-    UnicodeString fPadEscape;
-};
-
-U_NAMESPACE_END
-
-#endif /* !UCONFIG_NO_FORMATTING */
-#endif
diff --git a/deps/icu-small/source/i18n/decimalformatpatternimpl.h b/deps/icu-small/source/i18n/decimalformatpatternimpl.h
deleted file mode 100644
index 8cecc8cca02c72..00000000000000
--- a/deps/icu-small/source/i18n/decimalformatpatternimpl.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-********************************************************************************
-*   Copyright (C) 2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-********************************************************************************
-*
-* File decimalformatpatternimpl.h
-********************************************************************************
-*/
-
-#ifndef DECIMALFORMATPATTERNIMPL_H
-#define DECIMALFORMATPATTERNIMPL_H
-
-#include "unicode/utypes.h"
-
-#define kPatternZeroDigit            ((UChar)0x0030) /*'0'*/
-#define kPatternSignificantDigit     ((UChar)0x0040) /*'@'*/
-#define kPatternGroupingSeparator    ((UChar)0x002C) /*','*/
-#define kPatternDecimalSeparator     ((UChar)0x002E) /*'.'*/
-#define kPatternPerMill              ((UChar)0x2030)
-#define kPatternPercent              ((UChar)0x0025) /*'%'*/
-#define kPatternDigit                ((UChar)0x0023) /*'#'*/
-#define kPatternSeparator            ((UChar)0x003B) /*';'*/
-#define kPatternExponent             ((UChar)0x0045) /*'E'*/
-#define kPatternPlus                 ((UChar)0x002B) /*'+'*/
-#define kPatternMinus                ((UChar)0x002D) /*'-'*/
-#define kPatternPadEscape            ((UChar)0x002A) /*'*'*/
-#define kQuote                       ((UChar)0x0027) /*'\''*/
-
-#define kCurrencySign                ((UChar)0x00A4)
-#define kDefaultPad                  ((UChar)0x0020) /* */
-
-#endif
diff --git a/deps/icu-small/source/i18n/decimfmt.cpp b/deps/icu-small/source/i18n/decimfmt.cpp
index 80a9446e146f6c..a2638bb74298e3 100644
--- a/deps/icu-small/source/i18n/decimfmt.cpp
+++ b/deps/icu-small/source/i18n/decimfmt.cpp
@@ -1,3295 +1,1383 @@
-// © 2016 and later: Unicode, Inc. and others.
+// © 2018 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 1997-2015, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
-*******************************************************************************
-*
-* File DECIMFMT.CPP
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   02/19/97    aliu        Converted from java.
-*   03/20/97    clhuang     Implemented with new APIs.
-*   03/31/97    aliu        Moved isLONG_MIN to DigitList, and fixed it.
-*   04/3/97     aliu        Rewrote parsing and formatting completely, and
-*                           cleaned up and debugged.  Actually works now.
-*                           Implemented NAN and INF handling, for both parsing
-*                           and formatting.  Extensive testing & debugging.
-*   04/10/97    aliu        Modified to compile on AIX.
-*   04/16/97    aliu        Rewrote to use DigitList, which has been resurrected.
-*                           Changed DigitCount to int per code review.
-*   07/09/97    helena      Made ParsePosition into a class.
-*   08/26/97    aliu        Extensive changes to applyPattern; completely
-*                           rewritten from the Java.
-*   09/09/97    aliu        Ported over support for exponential formats.
-*   07/20/98    stephen     JDK 1.2 sync up.
-*                             Various instances of '0' replaced with 'NULL'
-*                             Check for grouping size in subFormat()
-*                             Brought subParse() in line with Java 1.2
-*                             Added method appendAffix()
-*   08/24/1998  srl         Removed Mutex calls. This is not a thread safe class!
-*   02/22/99    stephen     Removed character literals for EBCDIC safety
-*   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
-*   06/28/99    stephen     Fixed bugs in toPattern().
-*   06/29/99    stephen     Fixed operator= to copy fFormatWidth, fPad,
-*                             fPadPosition
-********************************************************************************
-*/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "unicode/uniset.h"
-#include "unicode/currpinf.h"
-#include "unicode/plurrule.h"
-#include "unicode/utf16.h"
-#include "unicode/numsys.h"
-#include "unicode/localpointer.h"
-#include "unicode/ustring.h"
-#include "uresimp.h"
-#include "ucurrimp.h"
-#include "charstr.h"
-#include "patternprops.h"
-#include "cstring.h"
-#include "uassert.h"
-#include "hash.h"
-#include "decfmtst.h"
-#include "plurrule_impl.h"
-#include "decimalformatpattern.h"
-#include "fmtableimp.h"
-#include "decimfmtimpl.h"
-#include "visibledigits.h"
-
-/*
- * On certain platforms, round is a macro defined in math.h
- * This undefine is to avoid conflict between the macro and
- * the function defined below.
- */
-#ifdef round
-#undef round
-#endif
-
-
-U_NAMESPACE_BEGIN
-
-#ifdef FMT_DEBUG
-#include <stdio.h>
-static void _debugout(const char *f, int l, const UnicodeString& s) {
-    char buf[2000];
-    s.extract((int32_t) 0, s.length(), buf, "utf-8");
-    printf("%s:%d: %s\n", f,l, buf);
-}
-#define debugout(x) _debugout(__FILE__,__LINE__,x)
-#define debug(x) printf("%s:%d: %s\n", __FILE__,__LINE__, x);
-static const UnicodeString dbg_null("<NULL>","");
-#define DEREFSTR(x)   ((x!=NULL)?(*x):(dbg_null))
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include <cmath>
+#include <cstdlib>
+#include <stdlib.h>
+#include "unicode/errorcode.h"
+#include "unicode/decimfmt.h"
+#include "number_decimalquantity.h"
+#include "number_types.h"
+#include "numparse_impl.h"
+#include "number_mapper.h"
+#include "number_patternstring.h"
+#include "putilimp.h"
+#include "number_utils.h"
+#include "number_utypes.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+using ERoundingMode = icu::DecimalFormat::ERoundingMode;
+using EPadPosition = icu::DecimalFormat::EPadPosition;
+
+// MSVC warns C4805 when comparing bool with UBool
+// TODO: Move this macro into a better place?
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+#define UBOOL_TO_BOOL(b) static_cast<bool>(b)
 #else
-#define debugout(x)
-#define debug(x)
-#endif
-
-
-/* For currency parsing purose,
- * Need to remember all prefix patterns and suffix patterns of
- * every currency format pattern,
- * including the pattern of default currecny style
- * and plural currency style. And the patterns are set through applyPattern.
- */
-struct AffixPatternsForCurrency : public UMemory {
-	// negative prefix pattern
-	UnicodeString negPrefixPatternForCurrency;
-	// negative suffix pattern
-	UnicodeString negSuffixPatternForCurrency;
-	// positive prefix pattern
-	UnicodeString posPrefixPatternForCurrency;
-	// positive suffix pattern
-	UnicodeString posSuffixPatternForCurrency;
-	int8_t patternType;
-
-	AffixPatternsForCurrency(const UnicodeString& negPrefix,
-							 const UnicodeString& negSuffix,
-							 const UnicodeString& posPrefix,
-							 const UnicodeString& posSuffix,
-							 int8_t type) {
-		negPrefixPatternForCurrency = negPrefix;
-		negSuffixPatternForCurrency = negSuffix;
-		posPrefixPatternForCurrency = posPrefix;
-		posSuffixPatternForCurrency = posSuffix;
-		patternType = type;
-	}
-#ifdef FMT_DEBUG
-  void dump() const  {
-    debugout( UnicodeString("AffixPatternsForCurrency( -=\"") +
-              negPrefixPatternForCurrency + (UnicodeString)"\"/\"" +
-              negSuffixPatternForCurrency + (UnicodeString)"\" +=\"" +
-              posPrefixPatternForCurrency + (UnicodeString)"\"/\"" +
-              posSuffixPatternForCurrency + (UnicodeString)"\" )");
-  }
+#define UBOOL_TO_BOOL(b) b
 #endif
-};
-
-/* affix for currency formatting when the currency sign in the pattern
- * equals to 3, such as the pattern contains 3 currency sign or
- * the formatter style is currency plural format style.
- */
-struct AffixesForCurrency : public UMemory {
-	// negative prefix
-	UnicodeString negPrefixForCurrency;
-	// negative suffix
-	UnicodeString negSuffixForCurrency;
-	// positive prefix
-	UnicodeString posPrefixForCurrency;
-	// positive suffix
-	UnicodeString posSuffixForCurrency;
-
-	int32_t formatWidth;
-
-	AffixesForCurrency(const UnicodeString& negPrefix,
-					   const UnicodeString& negSuffix,
-					   const UnicodeString& posPrefix,
-					   const UnicodeString& posSuffix) {
-		negPrefixForCurrency = negPrefix;
-		negSuffixForCurrency = negSuffix;
-		posPrefixForCurrency = posPrefix;
-		posSuffixForCurrency = posSuffix;
-	}
-#ifdef FMT_DEBUG
-  void dump() const {
-    debugout( UnicodeString("AffixesForCurrency( -=\"") +
-              negPrefixForCurrency + (UnicodeString)"\"/\"" +
-              negSuffixForCurrency + (UnicodeString)"\" +=\"" +
-              posPrefixForCurrency + (UnicodeString)"\"/\"" +
-              posSuffixForCurrency + (UnicodeString)"\" )");
-  }
-#endif
-};
-
-U_CDECL_BEGIN
-
-/**
- * @internal ICU 4.2
- */
-static UBool U_CALLCONV decimfmtAffixPatternValueComparator(UHashTok val1, UHashTok val2);
-
-
-static UBool
-U_CALLCONV decimfmtAffixPatternValueComparator(UHashTok val1, UHashTok val2) {
-    const AffixPatternsForCurrency* affix_1 =
-        (AffixPatternsForCurrency*)val1.pointer;
-    const AffixPatternsForCurrency* affix_2 =
-        (AffixPatternsForCurrency*)val2.pointer;
-    return affix_1->negPrefixPatternForCurrency ==
-           affix_2->negPrefixPatternForCurrency &&
-           affix_1->negSuffixPatternForCurrency ==
-           affix_2->negSuffixPatternForCurrency &&
-           affix_1->posPrefixPatternForCurrency ==
-           affix_2->posPrefixPatternForCurrency &&
-           affix_1->posSuffixPatternForCurrency ==
-           affix_2->posSuffixPatternForCurrency &&
-           affix_1->patternType == affix_2->patternType;
-}
-
-U_CDECL_END
-
 
 
-
-// *****************************************************************************
-// class DecimalFormat
-// *****************************************************************************
-
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DecimalFormat)
 
-// Constants for characters used in programmatic (unlocalized) patterns.
-#define kPatternZeroDigit            ((UChar)0x0030) /*'0'*/
-#define kPatternSignificantDigit     ((UChar)0x0040) /*'@'*/
-#define kPatternGroupingSeparator    ((UChar)0x002C) /*','*/
-#define kPatternDecimalSeparator     ((UChar)0x002E) /*'.'*/
-#define kPatternPerMill              ((UChar)0x2030)
-#define kPatternPercent              ((UChar)0x0025) /*'%'*/
-#define kPatternDigit                ((UChar)0x0023) /*'#'*/
-#define kPatternSeparator            ((UChar)0x003B) /*';'*/
-#define kPatternExponent             ((UChar)0x0045) /*'E'*/
-#define kPatternPlus                 ((UChar)0x002B) /*'+'*/
-#define kPatternMinus                ((UChar)0x002D) /*'-'*/
-#define kPatternPadEscape            ((UChar)0x002A) /*'*'*/
-#define kQuote                       ((UChar)0x0027) /*'\''*/
-/**
- * The CURRENCY_SIGN is the standard Unicode symbol for currency.  It
- * is used in patterns and substitued with either the currency symbol,
- * or if it is doubled, with the international currency symbol.  If the
- * CURRENCY_SIGN is seen in a pattern, then the decimal separator is
- * replaced with the monetary decimal separator.
- */
-#define kCurrencySign                ((UChar)0x00A4)
-#define kDefaultPad                  ((UChar)0x0020) /* */
-
-const int32_t DecimalFormat::kDoubleIntegerDigits  = 309;
-const int32_t DecimalFormat::kDoubleFractionDigits = 340;
-
-const int32_t DecimalFormat::kMaxScientificIntegerDigits = 8;
-
-/**
- * These are the tags we expect to see in normal resource bundle files associated
- * with a locale.
- */
-const char DecimalFormat::fgNumberPatterns[]="NumberPatterns"; // Deprecated - not used
-static const char fgNumberElements[]="NumberElements";
-static const char fgLatn[]="latn";
-static const char fgPatterns[]="patterns";
-static const char fgDecimalFormat[]="decimalFormat";
-static const char fgCurrencyFormat[]="currencyFormat";
-
-inline int32_t _min(int32_t a, int32_t b) { return (a<b) ? a : b; }
-inline int32_t _max(int32_t a, int32_t b) { return (a<b) ? b : a; }
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance in the default locale.
-
-DecimalFormat::DecimalFormat(UErrorCode& status) {
-    init();
-    UParseError parseError;
-    construct(status, parseError);
-}
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance with the specified number format
-// pattern in the default locale.
-
-DecimalFormat::DecimalFormat(const UnicodeString& pattern,
-                             UErrorCode& status) {
-    init();
-    UParseError parseError;
-    construct(status, parseError, &pattern);
-}
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance with the specified number format
-// pattern and the number format symbols in the default locale.  The
-// created instance owns the symbols.
-
-DecimalFormat::DecimalFormat(const UnicodeString& pattern,
-                             DecimalFormatSymbols* symbolsToAdopt,
-                             UErrorCode& status) {
-    init();
-    UParseError parseError;
-    if (symbolsToAdopt == NULL)
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-    construct(status, parseError, &pattern, symbolsToAdopt);
-}
-
-DecimalFormat::DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UParseError& parseErr,
-                    UErrorCode& status) {
-    init();
-    if (symbolsToAdopt == NULL)
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-    construct(status,parseErr, &pattern, symbolsToAdopt);
-}
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance with the specified number format
-// pattern and the number format symbols in the default locale.  The
-// created instance owns the clone of the symbols.
-
-DecimalFormat::DecimalFormat(const UnicodeString& pattern,
-                             const DecimalFormatSymbols& symbols,
-                             UErrorCode& status) {
-    init();
-    UParseError parseError;
-    construct(status, parseError, &pattern, new DecimalFormatSymbols(symbols));
-}
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance with the specified number format
-// pattern, the number format symbols, and the number format style.
-// The created instance owns the clone of the symbols.
-
-DecimalFormat::DecimalFormat(const UnicodeString& pattern,
-                             DecimalFormatSymbols* symbolsToAdopt,
-                             UNumberFormatStyle style,
-                             UErrorCode& status) {
-    init();
-    fStyle = style;
-    UParseError parseError;
-    construct(status, parseError, &pattern, symbolsToAdopt);
-}
-
-//-----------------------------------------------------------------------------
-// Common DecimalFormat initialization.
-//    Put all fields of an uninitialized object into a known state.
-//    Common code, shared by all constructors.
-//    Can not fail. Leave the object in good enough shape that the destructor
-//    or assignment operator can run successfully.
-void
-DecimalFormat::init() {
-    fBoolFlags.clear();
-    fStyle = UNUM_DECIMAL;
-    fAffixPatternsForCurrency = NULL;
-    fCurrencyPluralInfo = NULL;
-#if UCONFIG_HAVE_PARSEALLINPUT
-    fParseAllInput = UNUM_MAYBE;
-#endif
-
-    fStaticSets = NULL;
-    fImpl = NULL;
-}
-
-//------------------------------------------------------------------------------
-// Constructs a DecimalFormat instance with the specified number format
-// pattern and the number format symbols in the desired locale.  The
-// created instance owns the symbols.
-
-void
-DecimalFormat::construct(UErrorCode&            status,
-                         UParseError&           parseErr,
-                         const UnicodeString*   pattern,
-                         DecimalFormatSymbols*  symbolsToAdopt)
-{
-    LocalPointer<DecimalFormatSymbols> adoptedSymbols(symbolsToAdopt);
-    if (U_FAILURE(status))
-        return;
-
-    if (adoptedSymbols.isNull())
-    {
-        adoptedSymbols.adoptInstead(
-                new DecimalFormatSymbols(Locale::getDefault(), status));
-        if (adoptedSymbols.isNull() && U_SUCCESS(status)) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-        }
-        if (U_FAILURE(status)) {
-            return;
-        }
-    }
-    fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    UnicodeString str;
-    // Uses the default locale's number format pattern if there isn't
-    // one specified.
-    if (pattern == NULL)
-    {
-        UErrorCode nsStatus = U_ZERO_ERROR;
-        LocalPointer<NumberingSystem> ns(
-                NumberingSystem::createInstance(nsStatus));
-        if (U_FAILURE(nsStatus)) {
-            status = nsStatus;
-            return;
-        }
-
-        int32_t len = 0;
-        UResourceBundle *top = ures_open(NULL, Locale::getDefault().getName(), &status);
-
-        UResourceBundle *resource = ures_getByKeyWithFallback(top, fgNumberElements, NULL, &status);
-        resource = ures_getByKeyWithFallback(resource, ns->getName(), resource, &status);
-        resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &status);
-        const UChar *resStr = ures_getStringByKeyWithFallback(resource, fgDecimalFormat, &len, &status);
-        if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(fgLatn,ns->getName())) {
-            status = U_ZERO_ERROR;
-            resource = ures_getByKeyWithFallback(top, fgNumberElements, resource, &status);
-            resource = ures_getByKeyWithFallback(resource, fgLatn, resource, &status);
-            resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &status);
-            resStr = ures_getStringByKeyWithFallback(resource, fgDecimalFormat, &len, &status);
-        }
-        str.setTo(TRUE, resStr, len);
-        pattern = &str;
-        ures_close(resource);
-        ures_close(top);
-    }
-
-    fImpl = new DecimalFormatImpl(this, *pattern, adoptedSymbols.getAlias(), parseErr, status);
-    if (fImpl) {
-        adoptedSymbols.orphan();
-    } else if (U_SUCCESS(status)) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    if (U_FAILURE(status))
-    {
-        return;
-    }
-
-    const UnicodeString* patternUsed;
-    UnicodeString currencyPluralPatternForOther;
-    // apply pattern
-    if (fStyle == UNUM_CURRENCY_PLURAL) {
-        fCurrencyPluralInfo = new CurrencyPluralInfo(fImpl->fSymbols->getLocale(), status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-
-        // the pattern used in format is not fixed until formatting,
-        // in which, the number is known and
-        // will be used to pick the right pattern based on plural count.
-        // Here, set the pattern as the pattern of plural count == "other".
-        // For most locale, the patterns are probably the same for all
-        // plural count. If not, the right pattern need to be re-applied
-        // during format.
-        fCurrencyPluralInfo->getCurrencyPluralPattern(UNICODE_STRING("other", 5), currencyPluralPatternForOther);
-        // TODO(refactor): Revisit, we are setting the pattern twice.
-        fImpl->applyPatternFavorCurrencyPrecision(
-                currencyPluralPatternForOther, status);
-        patternUsed = &currencyPluralPatternForOther;
 
+DecimalFormat::DecimalFormat(UErrorCode& status)
+        : DecimalFormat(nullptr, status) {
+    // Use the default locale and decimal pattern.
+    const char* localeName = Locale::getDefault().getName();
+    LocalPointer<NumberingSystem> ns(NumberingSystem::createInstance(status));
+    UnicodeString patternString = utils::getPatternForStyle(
+            localeName,
+            ns->getName(),
+            CLDR_PATTERN_STYLE_DECIMAL,
+            status);
+    setPropertiesFromPattern(patternString, IGNORE_ROUNDING_IF_CURRENCY, status);
+    touch(status);
+}
+
+DecimalFormat::DecimalFormat(const UnicodeString& pattern, UErrorCode& status)
+        : DecimalFormat(nullptr, status) {
+    setPropertiesFromPattern(pattern, IGNORE_ROUNDING_IF_CURRENCY, status);
+    touch(status);
+}
+
+DecimalFormat::DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                             UErrorCode& status)
+        : DecimalFormat(symbolsToAdopt, status) {
+    setPropertiesFromPattern(pattern, IGNORE_ROUNDING_IF_CURRENCY, status);
+    touch(status);
+}
+
+DecimalFormat::DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                             UNumberFormatStyle style, UErrorCode& status)
+        : DecimalFormat(symbolsToAdopt, status) {
+    // If choice is a currency type, ignore the rounding information.
+    if (style == UNumberFormatStyle::UNUM_CURRENCY || style == UNumberFormatStyle::UNUM_CURRENCY_ISO ||
+        style == UNumberFormatStyle::UNUM_CURRENCY_ACCOUNTING ||
+        style == UNumberFormatStyle::UNUM_CASH_CURRENCY ||
+        style == UNumberFormatStyle::UNUM_CURRENCY_STANDARD ||
+        style == UNumberFormatStyle::UNUM_CURRENCY_PLURAL) {
+        setPropertiesFromPattern(pattern, IGNORE_ROUNDING_ALWAYS, status);
     } else {
-        patternUsed = pattern;
+        setPropertiesFromPattern(pattern, IGNORE_ROUNDING_IF_CURRENCY, status);
     }
-
-    if (patternUsed->indexOf(kCurrencySign) != -1) {
-        // initialize for currency, not only for plural format,
-        // but also for mix parsing
-        handleCurrencySignInPattern(status);
+    // Note: in Java, CurrencyPluralInfo is set in NumberFormat.java, but in C++, it is not set there,
+    // so we have to set it here.
+    if (style == UNumberFormatStyle::UNUM_CURRENCY_PLURAL) {
+        LocalPointer<CurrencyPluralInfo> cpi(
+                new CurrencyPluralInfo(fields->symbols->getLocale(), status),
+                status);
+        if (U_FAILURE(status)) { return; }
+        fields->properties->currencyPluralInfo.fPtr.adoptInstead(cpi.orphan());
     }
+    touch(status);
 }
 
-void
-DecimalFormat::handleCurrencySignInPattern(UErrorCode& status) {
-    // initialize for currency, not only for plural format,
-    // but also for mix parsing
+DecimalFormat::DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status) {
+    LocalPointer<const DecimalFormatSymbols> adoptedSymbols(symbolsToAdopt);
+    fields = new DecimalFormatFields();
     if (U_FAILURE(status)) {
         return;
     }
-    if (fCurrencyPluralInfo == NULL) {
-       fCurrencyPluralInfo = new CurrencyPluralInfo(fImpl->fSymbols->getLocale(), status);
-       if (U_FAILURE(status)) {
-           return;
-       }
-    }
-    // need it for mix parsing
-    if (fAffixPatternsForCurrency == NULL) {
-        setupCurrencyAffixPatterns(status);
-    }
-}
-
-static void
-applyPatternWithNoSideEffects(
-        const UnicodeString& pattern,
-        UParseError& parseError,
-        UnicodeString &negPrefix,
-        UnicodeString &negSuffix,
-        UnicodeString &posPrefix,
-        UnicodeString &posSuffix,
-        UErrorCode& status) {
-        if (U_FAILURE(status))
-    {
+    if (fields == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
-    DecimalFormatPatternParser patternParser;
-    DecimalFormatPattern out;
-    patternParser.applyPatternWithoutExpandAffix(
-        pattern,
-        out,
-        parseError,
-        status);
-    if (U_FAILURE(status)) {
-      return;
+    fields->properties.adoptInsteadAndCheckErrorCode(new DecimalFormatProperties(), status);
+    fields->exportedProperties.adoptInsteadAndCheckErrorCode(new DecimalFormatProperties(), status);
+    if (adoptedSymbols.isNull()) {
+        fields->symbols.adoptInsteadAndCheckErrorCode(new DecimalFormatSymbols(status), status);
+    } else {
+        fields->symbols.adoptInsteadAndCheckErrorCode(adoptedSymbols.orphan(), status);
     }
-    negPrefix = out.fNegPrefixPattern;
-    negSuffix = out.fNegSuffixPattern;
-    posPrefix = out.fPosPrefixPattern;
-    posSuffix = out.fPosSuffixPattern;
 }
 
-void
-DecimalFormat::setupCurrencyAffixPatterns(UErrorCode& status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    UParseError parseErr;
-    fAffixPatternsForCurrency = initHashForAffixPattern(status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    NumberingSystem *ns = NumberingSystem::createInstance(fImpl->fSymbols->getLocale(),status);
-    if (U_FAILURE(status)) {
-        return;
-    }
+#if UCONFIG_HAVE_PARSEALLINPUT
 
-    // Save the default currency patterns of this locale.
-    // Here, chose onlyApplyPatternWithoutExpandAffix without
-    // expanding the affix patterns into affixes.
-    UnicodeString currencyPattern;
-    UErrorCode error = U_ZERO_ERROR;
-
-    UResourceBundle *resource = ures_open(NULL, fImpl->fSymbols->getLocale().getName(), &error);
-    UResourceBundle *numElements = ures_getByKeyWithFallback(resource, fgNumberElements, NULL, &error);
-    resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &error);
-    resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &error);
-    int32_t patLen = 0;
-    const UChar *patResStr = ures_getStringByKeyWithFallback(resource, fgCurrencyFormat,  &patLen, &error);
-    if ( error == U_MISSING_RESOURCE_ERROR && uprv_strcmp(ns->getName(),fgLatn)) {
-        error = U_ZERO_ERROR;
-        resource = ures_getByKeyWithFallback(numElements, fgLatn, resource, &error);
-        resource = ures_getByKeyWithFallback(resource, fgPatterns, resource, &error);
-        patResStr = ures_getStringByKeyWithFallback(resource, fgCurrencyFormat,  &patLen, &error);
-    }
-    ures_close(numElements);
-    ures_close(resource);
-    delete ns;
-
-    if (U_SUCCESS(error)) {
-        UnicodeString negPrefix;
-        UnicodeString negSuffix;
-        UnicodeString posPrefix;
-        UnicodeString posSuffix;
-        applyPatternWithNoSideEffects(UnicodeString(patResStr, patLen),
-                                       parseErr,
-                negPrefix, negSuffix, posPrefix, posSuffix,  status);
-        AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency(
-                                                    negPrefix,
-                                                    negSuffix,
-                                                    posPrefix,
-                                                    posSuffix,
-                                                    UCURR_SYMBOL_NAME);
-        fAffixPatternsForCurrency->put(UNICODE_STRING("default", 7), affixPtn, status);
-    }
-
-    // save the unique currency plural patterns of this locale.
-    Hashtable* pluralPtn = fCurrencyPluralInfo->fPluralCountToCurrencyUnitPattern;
-    const UHashElement* element = NULL;
-    int32_t pos = UHASH_FIRST;
-    Hashtable pluralPatternSet;
-    while ((element = pluralPtn->nextElement(pos)) != NULL) {
-        const UHashTok valueTok = element->value;
-        const UnicodeString* value = (UnicodeString*)valueTok.pointer;
-        const UHashTok keyTok = element->key;
-        const UnicodeString* key = (UnicodeString*)keyTok.pointer;
-        if (pluralPatternSet.geti(*value) != 1) {
-            UnicodeString negPrefix;
-            UnicodeString negSuffix;
-            UnicodeString posPrefix;
-            UnicodeString posSuffix;
-            pluralPatternSet.puti(*value, 1, status);
-            applyPatternWithNoSideEffects(
-                    *value, parseErr,
-                    negPrefix, negSuffix, posPrefix, posSuffix, status);
-            AffixPatternsForCurrency* affixPtn = new AffixPatternsForCurrency(
-                                                    negPrefix,
-                                                    negSuffix,
-                                                    posPrefix,
-                                                    posSuffix,
-                                                    UCURR_LONG_NAME);
-            fAffixPatternsForCurrency->put(*key, affixPtn, status);
-        }
-    }
+void DecimalFormat::setParseAllInput(UNumberFormatAttributeValue value) {
+    if (value == fields->properties->parseAllInput) { return; }
+    fields->properties->parseAllInput = value;
 }
 
+#endif
 
-//------------------------------------------------------------------------------
+DecimalFormat&
+DecimalFormat::setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status) {
+    if (U_FAILURE(status)) { return *this; }
 
-DecimalFormat::~DecimalFormat()
-{
-    deleteHashForAffixPattern();
-    delete fCurrencyPluralInfo;
-    delete fImpl;
-}
+    switch (attr) {
+        case UNUM_LENIENT_PARSE:
+            setLenient(newValue != 0);
+            break;
 
-//------------------------------------------------------------------------------
-// copy constructor
+        case UNUM_PARSE_INT_ONLY:
+            setParseIntegerOnly(newValue != 0);
+            break;
 
-DecimalFormat::DecimalFormat(const DecimalFormat &source) :
-    NumberFormat(source) {
-    init();
-    *this = source;
-}
+        case UNUM_GROUPING_USED:
+            setGroupingUsed(newValue != 0);
+            break;
 
-//------------------------------------------------------------------------------
-// assignment operator
+        case UNUM_DECIMAL_ALWAYS_SHOWN:
+            setDecimalSeparatorAlwaysShown(newValue != 0);
+            break;
 
-template <class T>
-static void _clone_ptr(T** pdest, const T* source) {
-    delete *pdest;
-    if (source == NULL) {
-        *pdest = NULL;
-    } else {
-        *pdest = static_cast<T*>(source->clone());
-    }
-}
+        case UNUM_MAX_INTEGER_DIGITS:
+            setMaximumIntegerDigits(newValue);
+            break;
 
-DecimalFormat&
-DecimalFormat::operator=(const DecimalFormat& rhs)
-{
-    if(this != &rhs) {
-        UErrorCode status = U_ZERO_ERROR;
-        NumberFormat::operator=(rhs);
-        if (fImpl == NULL) {
-            fImpl = new DecimalFormatImpl(this, *rhs.fImpl, status);
-        } else {
-            fImpl->assign(*rhs.fImpl, status);
-        }
-        fStaticSets     = DecimalFormatStaticSets::getStaticSets(status);
-        fStyle = rhs.fStyle;
-        _clone_ptr(&fCurrencyPluralInfo, rhs.fCurrencyPluralInfo);
-        deleteHashForAffixPattern();
-        if (rhs.fAffixPatternsForCurrency) {
-            UErrorCode status = U_ZERO_ERROR;
-            fAffixPatternsForCurrency = initHashForAffixPattern(status);
-            copyHashForAffixPattern(rhs.fAffixPatternsForCurrency,
-                                    fAffixPatternsForCurrency, status);
-        }
-    }
+        case UNUM_MIN_INTEGER_DIGITS:
+            setMinimumIntegerDigits(newValue);
+            break;
 
-    return *this;
-}
+        case UNUM_INTEGER_DIGITS:
+            setMinimumIntegerDigits(newValue);
+            setMaximumIntegerDigits(newValue);
+            break;
 
-//------------------------------------------------------------------------------
+        case UNUM_MAX_FRACTION_DIGITS:
+            setMaximumFractionDigits(newValue);
+            break;
 
-UBool
-DecimalFormat::operator==(const Format& that) const
-{
-    if (this == &that)
-        return TRUE;
+        case UNUM_MIN_FRACTION_DIGITS:
+            setMinimumFractionDigits(newValue);
+            break;
 
-    // NumberFormat::operator== guarantees this cast is safe
-    const DecimalFormat* other = (DecimalFormat*)&that;
+        case UNUM_FRACTION_DIGITS:
+            setMinimumFractionDigits(newValue);
+            setMaximumFractionDigits(newValue);
+            break;
 
-    return (
-        NumberFormat::operator==(that) &&
-        fBoolFlags.getAll() == other->fBoolFlags.getAll() &&
-        *fImpl == *other->fImpl);
+        case UNUM_SIGNIFICANT_DIGITS_USED:
+            setSignificantDigitsUsed(newValue != 0);
+            break;
 
-}
+        case UNUM_MAX_SIGNIFICANT_DIGITS:
+            setMaximumSignificantDigits(newValue);
+            break;
 
-//------------------------------------------------------------------------------
+        case UNUM_MIN_SIGNIFICANT_DIGITS:
+            setMinimumSignificantDigits(newValue);
+            break;
 
-Format*
-DecimalFormat::clone() const
-{
-    return new DecimalFormat(*this);
-}
+        case UNUM_MULTIPLIER:
+            setMultiplier(newValue);
+            break;
 
+        case UNUM_SCALE:
+            setMultiplierScale(newValue);
+            break;
 
-FixedDecimal
-DecimalFormat::getFixedDecimal(double number, UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    if (U_FAILURE(status)) {
-        return FixedDecimal();
-    }
-    return FixedDecimal(digits.getMantissa());
-}
+        case UNUM_GROUPING_SIZE:
+            setGroupingSize(newValue);
+            break;
 
-VisibleDigitsWithExponent &
-DecimalFormat::initVisibleDigitsWithExponent(
-        double number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    return fImpl->initVisibleDigitsWithExponent(number, digits, status);
-}
+        case UNUM_ROUNDING_MODE:
+            setRoundingMode((DecimalFormat::ERoundingMode) newValue);
+            break;
 
-FixedDecimal
-DecimalFormat::getFixedDecimal(const Formattable &number, UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    if (U_FAILURE(status)) {
-        return FixedDecimal();
-    }
-    return FixedDecimal(digits.getMantissa());
-}
+        case UNUM_FORMAT_WIDTH:
+            setFormatWidth(newValue);
+            break;
 
-VisibleDigitsWithExponent &
-DecimalFormat::initVisibleDigitsWithExponent(
-        const Formattable &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    if (!number.isNumeric()) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return digits;
-    }
+        case UNUM_PADDING_POSITION:
+            /** The position at which padding will take place. */
+            setPadPosition((DecimalFormat::EPadPosition) newValue);
+            break;
 
-    DigitList *dl = number.getDigitList();
-    if (dl != NULL) {
-        DigitList dlCopy(*dl);
-        return fImpl->initVisibleDigitsWithExponent(
-                dlCopy, digits, status);
-    }
+        case UNUM_SECONDARY_GROUPING_SIZE:
+            setSecondaryGroupingSize(newValue);
+            break;
 
-    Formattable::Type type = number.getType();
-    if (type == Formattable::kDouble || type == Formattable::kLong) {
-        return fImpl->initVisibleDigitsWithExponent(
-                number.getDouble(status), digits, status);
-    }
-    return fImpl->initVisibleDigitsWithExponent(
-            number.getInt64(), digits, status);
-}
+#if UCONFIG_HAVE_PARSEALLINPUT
+        case UNUM_PARSE_ALL_INPUT:
+            setParseAllInput((UNumberFormatAttributeValue) newValue);
+            break;
+#endif
 
+        case UNUM_PARSE_NO_EXPONENT:
+            setParseNoExponent((UBool) newValue);
+            break;
 
-// Create a fixed decimal from a DigitList.
-//    The digit list may be modified.
-//    Internal function only.
-FixedDecimal
-DecimalFormat::getFixedDecimal(DigitList &number, UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    if (U_FAILURE(status)) {
-        return FixedDecimal();
-    }
-    return FixedDecimal(digits.getMantissa());
-}
+        case UNUM_PARSE_DECIMAL_MARK_REQUIRED:
+            setDecimalPatternMatchRequired((UBool) newValue);
+            break;
 
-VisibleDigitsWithExponent &
-DecimalFormat::initVisibleDigitsWithExponent(
-        DigitList &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    return fImpl->initVisibleDigitsWithExponent(
-            number, digits, status);
-}
+        case UNUM_CURRENCY_USAGE:
+            setCurrencyUsage((UCurrencyUsage) newValue, &status);
+            break;
 
+        case UNUM_MINIMUM_GROUPING_DIGITS:
+            setMinimumGroupingDigits(newValue);
+            break;
 
-//------------------------------------------------------------------------------
+        case UNUM_PARSE_CASE_SENSITIVE:
+            setParseCaseSensitive(static_cast<UBool>(newValue));
+            break;
 
-UnicodeString&
-DecimalFormat::format(int32_t number,
-                      UnicodeString& appendTo,
-                      FieldPosition& fieldPosition) const
-{
-    UErrorCode status = U_ZERO_ERROR;
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_SIGN_ALWAYS_SHOWN:
+            setSignAlwaysShown(static_cast<UBool>(newValue));
+            break;
 
-UnicodeString&
-DecimalFormat::format(int32_t number,
-                      UnicodeString& appendTo,
-                      FieldPosition& fieldPosition,
-                      UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS:
+            setFormatFailIfMoreThanMaxDigits(static_cast<UBool>(newValue));
+            break;
 
-UnicodeString&
-DecimalFormat::format(int32_t number,
-                      UnicodeString& appendTo,
-                      FieldPositionIterator* posIter,
-                      UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, posIter, status);
+        default:
+            status = U_UNSUPPORTED_ERROR;
+            break;
+    }
+    return *this;
 }
 
+int32_t DecimalFormat::getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const {
+    if (U_FAILURE(status)) { return -1; }
+    switch (attr) {
+        case UNUM_LENIENT_PARSE:
+            return isLenient();
 
-//------------------------------------------------------------------------------
+        case UNUM_PARSE_INT_ONLY:
+            return isParseIntegerOnly();
 
-UnicodeString&
-DecimalFormat::format(int64_t number,
-                      UnicodeString& appendTo,
-                      FieldPosition& fieldPosition) const
-{
-    UErrorCode status = U_ZERO_ERROR; /* ignored */
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_GROUPING_USED:
+            return isGroupingUsed();
 
-UnicodeString&
-DecimalFormat::format(int64_t number,
-                      UnicodeString& appendTo,
-                      FieldPosition& fieldPosition,
-                      UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_DECIMAL_ALWAYS_SHOWN:
+            return isDecimalSeparatorAlwaysShown();
 
-UnicodeString&
-DecimalFormat::format(int64_t number,
-                      UnicodeString& appendTo,
-                      FieldPositionIterator* posIter,
-                      UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, posIter, status);
-}
+        case UNUM_MAX_INTEGER_DIGITS:
+            return getMaximumIntegerDigits();
 
-//------------------------------------------------------------------------------
+        case UNUM_MIN_INTEGER_DIGITS:
+            return getMinimumIntegerDigits();
 
-UnicodeString&
-DecimalFormat::format(  double number,
-                        UnicodeString& appendTo,
-                        FieldPosition& fieldPosition) const
-{
-    UErrorCode status = U_ZERO_ERROR; /* ignored */
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_INTEGER_DIGITS:
+            // TBD: what should this return?
+            return getMinimumIntegerDigits();
 
-UnicodeString&
-DecimalFormat::format(  double number,
-                        UnicodeString& appendTo,
-                        FieldPosition& fieldPosition,
-                        UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, fieldPosition, status);
-}
+        case UNUM_MAX_FRACTION_DIGITS:
+            return getMaximumFractionDigits();
 
-UnicodeString&
-DecimalFormat::format(  double number,
-                        UnicodeString& appendTo,
-                        FieldPositionIterator* posIter,
-                        UErrorCode& status) const
-{
-    return fImpl->format(number, appendTo, posIter, status);
-}
+        case UNUM_MIN_FRACTION_DIGITS:
+            return getMinimumFractionDigits();
 
-//------------------------------------------------------------------------------
+        case UNUM_FRACTION_DIGITS:
+            // TBD: what should this return?
+            return getMinimumFractionDigits();
 
+        case UNUM_SIGNIFICANT_DIGITS_USED:
+            return areSignificantDigitsUsed();
 
-UnicodeString&
-DecimalFormat::format(StringPiece number,
-                      UnicodeString &toAppendTo,
-                      FieldPositionIterator *posIter,
-                      UErrorCode &status) const
-{
-  return fImpl->format(number, toAppendTo, posIter, status);
-}
+        case UNUM_MAX_SIGNIFICANT_DIGITS:
+            return getMaximumSignificantDigits();
 
+        case UNUM_MIN_SIGNIFICANT_DIGITS:
+            return getMinimumSignificantDigits();
 
-UnicodeString&
-DecimalFormat::format(const DigitList &number,
-                      UnicodeString &appendTo,
-                      FieldPositionIterator *posIter,
-                      UErrorCode &status) const {
-    return fImpl->format(number, appendTo, posIter, status);
-}
+        case UNUM_MULTIPLIER:
+            return getMultiplier();
 
+        case UNUM_SCALE:
+            return getMultiplierScale();
 
-UnicodeString&
-DecimalFormat::format(const DigitList &number,
-                     UnicodeString& appendTo,
-                     FieldPosition& pos,
-                     UErrorCode &status) const {
-    return fImpl->format(number, appendTo, pos, status);
-}
+        case UNUM_GROUPING_SIZE:
+            return getGroupingSize();
 
-UnicodeString&
-DecimalFormat::format(const VisibleDigitsWithExponent &number,
-                      UnicodeString &appendTo,
-                      FieldPositionIterator *posIter,
-                      UErrorCode &status) const {
-    return fImpl->format(number, appendTo, posIter, status);
-}
+        case UNUM_ROUNDING_MODE:
+            return getRoundingMode();
 
+        case UNUM_FORMAT_WIDTH:
+            return getFormatWidth();
 
-UnicodeString&
-DecimalFormat::format(const VisibleDigitsWithExponent &number,
-                     UnicodeString& appendTo,
-                     FieldPosition& pos,
-                     UErrorCode &status) const {
-    return fImpl->format(number, appendTo, pos, status);
-}
+        case UNUM_PADDING_POSITION:
+            return getPadPosition();
 
-DigitList&
-DecimalFormat::_round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const {
-    adjustedNum = number;
-    fImpl->round(adjustedNum, status);
-    isNegative = !adjustedNum.isPositive();
-    return adjustedNum;
-}
+        case UNUM_SECONDARY_GROUPING_SIZE:
+            return getSecondaryGroupingSize();
 
-void
-DecimalFormat::parse(const UnicodeString& text,
-                     Formattable& result,
-                     ParsePosition& parsePosition) const {
-    parse(text, result, parsePosition, NULL);
-}
-
-CurrencyAmount* DecimalFormat::parseCurrency(const UnicodeString& text,
-                                             ParsePosition& pos) const {
-    Formattable parseResult;
-    int32_t start = pos.getIndex();
-    UChar curbuf[4] = {};
-    parse(text, parseResult, pos, curbuf);
-    if (pos.getIndex() != start) {
-        UErrorCode ec = U_ZERO_ERROR;
-        LocalPointer<CurrencyAmount> currAmt(new CurrencyAmount(parseResult, curbuf, ec), ec);
-        if (U_FAILURE(ec)) {
-            pos.setIndex(start); // indicate failure
-        } else {
-            return currAmt.orphan();
-        }
-    }
-    return NULL;
-}
-
-/**
- * Parses the given text as a number, optionally providing a currency amount.
- * @param text the string to parse
- * @param result output parameter for the numeric result.
- * @param parsePosition input-output position; on input, the
- * position within text to match; must have 0 <= pos.getIndex() <
- * text.length(); on output, the position after the last matched
- * character. If the parse fails, the position in unchanged upon
- * output.
- * @param currency if non-NULL, it should point to a 4-UChar buffer.
- * In this case the text is parsed as a currency format, and the
- * ISO 4217 code for the parsed currency is put into the buffer.
- * Otherwise the text is parsed as a non-currency format.
- */
-void DecimalFormat::parse(const UnicodeString& text,
-                          Formattable& result,
-                          ParsePosition& parsePosition,
-                          UChar* currency) const {
-    int32_t startIdx, backup;
-    int32_t i = startIdx = backup = parsePosition.getIndex();
-
-    // clear any old contents in the result.  In particular, clears any DigitList
-    //   that it may be holding.
-    result.setLong(0);
-    if (currency != NULL) {
-        for (int32_t ci=0; ci<4; ci++) {
-            currency[ci] = 0;
-        }
-    }
+        case UNUM_PARSE_NO_EXPONENT:
+            return isParseNoExponent();
 
-    // Handle NaN as a special case:
-    int32_t formatWidth = fImpl->getOldFormatWidth();
+        case UNUM_PARSE_DECIMAL_MARK_REQUIRED:
+            return isDecimalPatternMatchRequired();
 
-    // Skip padding characters, if around prefix
-    if (formatWidth > 0 && (
-            fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix ||
-            fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix)) {
-        i = skipPadding(text, i);
-    }
+        case UNUM_CURRENCY_USAGE:
+            return getCurrencyUsage();
 
-    if (isLenient()) {
-        // skip any leading whitespace
-        i = backup = skipUWhiteSpace(text, i);
-    }
+        case UNUM_MINIMUM_GROUPING_DIGITS:
+            return getMinimumGroupingDigits();
 
-    // If the text is composed of the representation of NaN, returns NaN.length
-    const UnicodeString *nan = &fImpl->getConstSymbol(DecimalFormatSymbols::kNaNSymbol);
-    int32_t nanLen = (text.compare(i, nan->length(), *nan)
-                      ? 0 : nan->length());
-    if (nanLen) {
-        i += nanLen;
-        if (formatWidth > 0 && (fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix || fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix)) {
-            i = skipPadding(text, i);
-        }
-        parsePosition.setIndex(i);
-        result.setDouble(uprv_getNaN());
-        return;
-    }
+        case UNUM_PARSE_CASE_SENSITIVE:
+            return isParseCaseSensitive();
 
-    // NaN parse failed; start over
-    i = backup;
-    parsePosition.setIndex(i);
+        case UNUM_SIGN_ALWAYS_SHOWN:
+            return isSignAlwaysShown();
 
-    // status is used to record whether a number is infinite.
-    UBool status[fgStatusLength];
+        case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS:
+            return isFormatFailIfMoreThanMaxDigits();
 
-    DigitList *digits = result.getInternalDigitList(); // get one from the stack buffer
-    if (digits == NULL) {
-        return;    // no way to report error from here.
+        default:
+            status = U_UNSUPPORTED_ERROR;
+            break;
     }
 
-    if (fImpl->fMonetary) {
-        if (!parseForCurrency(text, parsePosition, *digits,
-                              status, currency)) {
-          return;
-        }
-    } else {
-        if (!subparse(text,
-                      &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString(),
-                      &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString(),
-                      &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString(),
-                      &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString(),
-                      FALSE, UCURR_SYMBOL_NAME,
-                      parsePosition, *digits, status, currency)) {
-            debug("!subparse(...) - rewind");
-            parsePosition.setIndex(startIdx);
-            return;
-        }
-    }
+    return -1; /* undefined */
+}
 
-    // Handle infinity
-    if (status[fgStatusInfinite]) {
-        double inf = uprv_getInfinity();
-        result.setDouble(digits->isPositive() ? inf : -inf);
-        // TODO:  set the dl to infinity, and let it fall into the code below.
-    }
+void DecimalFormat::setGroupingUsed(UBool enabled) {
+    if (UBOOL_TO_BOOL(enabled) == fields->properties->groupingUsed) { return; }
+    NumberFormat::setGroupingUsed(enabled); // to set field for compatibility
+    fields->properties->groupingUsed = enabled;
+    touchNoError();
+}
 
-    else {
+void DecimalFormat::setParseIntegerOnly(UBool value) {
+    if (UBOOL_TO_BOOL(value) == fields->properties->parseIntegerOnly) { return; }
+    NumberFormat::setParseIntegerOnly(value); // to set field for compatibility
+    fields->properties->parseIntegerOnly = value;
+    touchNoError();
+}
 
-        if (!fImpl->fMultiplier.isZero()) {
-            UErrorCode ec = U_ZERO_ERROR;
-            digits->div(fImpl->fMultiplier, ec);
-        }
+void DecimalFormat::setLenient(UBool enable) {
+    ParseMode mode = enable ? PARSE_MODE_LENIENT : PARSE_MODE_STRICT;
+    if (!fields->properties->parseMode.isNull() && mode == fields->properties->parseMode.getNoError()) { return; }
+    NumberFormat::setLenient(enable); // to set field for compatibility
+    fields->properties->parseMode = mode;
+    touchNoError();
+}
 
-        if (fImpl->fScale != 0) {
-            DigitList ten;
-            ten.set((int32_t)10);
-            if (fImpl->fScale > 0) {
-                for (int32_t i = fImpl->fScale; i > 0; i--) {
-                    UErrorCode ec = U_ZERO_ERROR;
-                    digits->div(ten,ec);
-                }
-            } else {
-                for (int32_t i = fImpl->fScale; i < 0; i++) {
-                    UErrorCode ec = U_ZERO_ERROR;
-                    digits->mult(ten,ec);
-                }
-            }
-        }
+DecimalFormat::DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                             UParseError&, UErrorCode& status)
+        : DecimalFormat(symbolsToAdopt, status) {
+    // TODO: What is parseError for?
+    setPropertiesFromPattern(pattern, IGNORE_ROUNDING_IF_CURRENCY, status);
+    touch(status);
+}
 
-        // Negative zero special case:
-        //    if parsing integerOnly, change to +0, which goes into an int32 in a Formattable.
-        //    if not parsing integerOnly, leave as -0, which a double can represent.
-        if (digits->isZero() && !digits->isPositive() && isParseIntegerOnly()) {
-            digits->setPositive(TRUE);
-        }
-        result.adoptDigitList(digits);
-    }
-}
-
-
-
-UBool
-DecimalFormat::parseForCurrency(const UnicodeString& text,
-                                ParsePosition& parsePosition,
-                                DigitList& digits,
-                                UBool* status,
-                                UChar* currency) const {
-    UnicodeString positivePrefix;
-    UnicodeString positiveSuffix;
-    UnicodeString negativePrefix;
-    UnicodeString negativeSuffix;
-    fImpl->fPositivePrefixPattern.toString(positivePrefix);
-    fImpl->fPositiveSuffixPattern.toString(positiveSuffix);
-    fImpl->fNegativePrefixPattern.toString(negativePrefix);
-    fImpl->fNegativeSuffixPattern.toString(negativeSuffix);
-
-    int origPos = parsePosition.getIndex();
-    int maxPosIndex = origPos;
-    int maxErrorPos = -1;
-    // First, parse against current pattern.
-    // Since current pattern could be set by applyPattern(),
-    // it could be an arbitrary pattern, and it may not be the one
-    // defined in current locale.
-    UBool tmpStatus[fgStatusLength];
-    ParsePosition tmpPos(origPos);
-    DigitList tmpDigitList;
-    UBool found;
-    if (fStyle == UNUM_CURRENCY_PLURAL) {
-        found = subparse(text,
-                         &negativePrefix, &negativeSuffix,
-                         &positivePrefix, &positiveSuffix,
-                         TRUE, UCURR_LONG_NAME,
-                         tmpPos, tmpDigitList, tmpStatus, currency);
-    } else {
-        found = subparse(text,
-                         &negativePrefix, &negativeSuffix,
-                         &positivePrefix, &positiveSuffix,
-                         TRUE, UCURR_SYMBOL_NAME,
-                         tmpPos, tmpDigitList, tmpStatus, currency);
-    }
-    if (found) {
-        if (tmpPos.getIndex() > maxPosIndex) {
-            maxPosIndex = tmpPos.getIndex();
-            for (int32_t i = 0; i < fgStatusLength; ++i) {
-                status[i] = tmpStatus[i];
-            }
-            digits = tmpDigitList;
-        }
-    } else {
-        maxErrorPos = tmpPos.getErrorIndex();
-    }
-    // Then, parse against affix patterns.
-    // Those are currency patterns and currency plural patterns.
-    int32_t pos = UHASH_FIRST;
-    const UHashElement* element = NULL;
-    while ( (element = fAffixPatternsForCurrency->nextElement(pos)) != NULL ) {
-        const UHashTok valueTok = element->value;
-        const AffixPatternsForCurrency* affixPtn = (AffixPatternsForCurrency*)valueTok.pointer;
-        UBool tmpStatus[fgStatusLength];
-        ParsePosition tmpPos(origPos);
-        DigitList tmpDigitList;
-
-#ifdef FMT_DEBUG
-        debug("trying affix for currency..");
-        affixPtn->dump();
-#endif
+DecimalFormat::DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols,
+                             UErrorCode& status)
+        : DecimalFormat(new DecimalFormatSymbols(symbols), status) {
+    setPropertiesFromPattern(pattern, IGNORE_ROUNDING_IF_CURRENCY, status);
+    touch(status);
+}
 
-        UBool result = subparse(text,
-                                &affixPtn->negPrefixPatternForCurrency,
-                                &affixPtn->negSuffixPatternForCurrency,
-                                &affixPtn->posPrefixPatternForCurrency,
-                                &affixPtn->posSuffixPatternForCurrency,
-                                TRUE, affixPtn->patternType,
-                                tmpPos, tmpDigitList, tmpStatus, currency);
-        if (result) {
-            found = true;
-            if (tmpPos.getIndex() > maxPosIndex) {
-                maxPosIndex = tmpPos.getIndex();
-                for (int32_t i = 0; i < fgStatusLength; ++i) {
-                    status[i] = tmpStatus[i];
-                }
-                digits = tmpDigitList;
-            }
-        } else {
-            maxErrorPos = (tmpPos.getErrorIndex() > maxErrorPos) ?
-                          tmpPos.getErrorIndex() : maxErrorPos;
-        }
+DecimalFormat::DecimalFormat(const DecimalFormat& source) : NumberFormat(source) {
+    // Note: it is not safe to copy fields->formatter or fWarehouse directly because fields->formatter might have
+    // dangling pointers to fields inside fWarehouse. The safe thing is to re-construct fields->formatter from
+    // the property bag, despite being somewhat slower.
+    fields = new DecimalFormatFields();
+    if (fields == nullptr) {
+        return;
     }
-    // Finally, parse against simple affix to find the match.
-    // For example, in TestMonster suite,
-    // if the to-be-parsed text is "-\u00A40,00".
-    // complexAffixCompare will not find match,
-    // since there is no ISO code matches "\u00A4",
-    // and the parse stops at "\u00A4".
-    // We will just use simple affix comparison (look for exact match)
-    // to pass it.
-    //
-    // TODO: We should parse against simple affix first when
-    // output currency is not requested. After the complex currency
-    // parsing implementation was introduced, the default currency
-    // instance parsing slowed down because of the new code flow.
-    // I filed #10312 - Yoshito
-    UBool tmpStatus_2[fgStatusLength];
-    ParsePosition tmpPos_2(origPos);
-    DigitList tmpDigitList_2;
-
-    // Disable complex currency parsing and try it again.
-    UBool result = subparse(text,
-                            &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString(),
-                            &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString(),
-                            &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString(),
-                            &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString(),
-                            FALSE /* disable complex currency parsing */, UCURR_SYMBOL_NAME,
-                            tmpPos_2, tmpDigitList_2, tmpStatus_2,
-                            currency);
-    if (result) {
-        if (tmpPos_2.getIndex() > maxPosIndex) {
-            maxPosIndex = tmpPos_2.getIndex();
-            for (int32_t i = 0; i < fgStatusLength; ++i) {
-                status[i] = tmpStatus_2[i];
-            }
-            digits = tmpDigitList_2;
-        }
-        found = true;
-    } else {
-            maxErrorPos = (tmpPos_2.getErrorIndex() > maxErrorPos) ?
-                          tmpPos_2.getErrorIndex() : maxErrorPos;
+    fields->properties.adoptInstead(new DecimalFormatProperties(*source.fields->properties));
+    fields->symbols.adoptInstead(new DecimalFormatSymbols(*source.fields->symbols));
+    fields->exportedProperties.adoptInstead(new DecimalFormatProperties());
+    if (fields->properties == nullptr || fields->symbols == nullptr || fields->exportedProperties == nullptr) {
+        return;
     }
+    touchNoError();
+}
 
-    if (!found) {
-        //parsePosition.setIndex(origPos);
-        parsePosition.setErrorIndex(maxErrorPos);
-    } else {
-        parsePosition.setIndex(maxPosIndex);
-        parsePosition.setErrorIndex(-1);
-    }
-    return found;
-}
-
-
-/**
- * Parse the given text into a number.  The text is parsed beginning at
- * parsePosition, until an unparseable character is seen.
- * @param text the string to parse.
- * @param negPrefix negative prefix.
- * @param negSuffix negative suffix.
- * @param posPrefix positive prefix.
- * @param posSuffix positive suffix.
- * @param complexCurrencyParsing whether it is complex currency parsing or not.
- * @param type the currency type to parse against, LONG_NAME only or not.
- * @param parsePosition The position at which to being parsing.  Upon
- * return, the first unparsed character.
- * @param digits the DigitList to set to the parsed value.
- * @param status output param containing boolean status flags indicating
- * whether the value was infinite and whether it was positive.
- * @param currency return value for parsed currency, for generic
- * currency parsing mode, or NULL for normal parsing. In generic
- * currency parsing mode, any currency is parsed, not just the
- * currency that this formatter is set to.
- */
-UBool DecimalFormat::subparse(const UnicodeString& text,
-                              const UnicodeString* negPrefix,
-                              const UnicodeString* negSuffix,
-                              const UnicodeString* posPrefix,
-                              const UnicodeString* posSuffix,
-                              UBool complexCurrencyParsing,
-                              int8_t type,
-                              ParsePosition& parsePosition,
-                              DigitList& digits, UBool* status,
-                              UChar* currency) const
-{
-    //  The parsing process builds up the number as char string, in the neutral format that
-    //  will be acceptable to the decNumber library, then at the end passes that string
-    //  off for conversion to a decNumber.
-    UErrorCode err = U_ZERO_ERROR;
-    CharString parsedNum;
-    digits.setToZero();
-
-    int32_t position = parsePosition.getIndex();
-    int32_t oldStart = position;
-    int32_t textLength = text.length(); // One less pointer to follow
-    UBool strictParse = !isLenient();
-    UChar32 zero = fImpl->getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
-    const UnicodeString *groupingString = &fImpl->getConstSymbol(
-            !fImpl->fMonetary ?
-            DecimalFormatSymbols::kGroupingSeparatorSymbol : DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol);
-    UChar32 groupingChar = groupingString->char32At(0);
-    int32_t groupingStringLength = groupingString->length();
-    int32_t groupingCharLength   = U16_LENGTH(groupingChar);
-    UBool   groupingUsed = isGroupingUsed();
-#ifdef FMT_DEBUG
-    UChar dbgbuf[300];
-    UnicodeString s(dbgbuf,0,300);;
-    s.append((UnicodeString)"PARSE \"").append(text.tempSubString(position)).append((UnicodeString)"\" " );
-#define DBGAPPD(x) if(x) { s.append(UnicodeString(#x "="));  if(x->isEmpty()) { s.append(UnicodeString("<empty>")); } else { s.append(*x); } s.append(UnicodeString(" ")); } else { s.append(UnicodeString(#x "=NULL ")); }
-    DBGAPPD(negPrefix);
-    DBGAPPD(negSuffix);
-    DBGAPPD(posPrefix);
-    DBGAPPD(posSuffix);
-    debugout(s);
-#endif
-
-    UBool fastParseOk = false; /* TRUE iff fast parse is OK */
-    // UBool fastParseHadDecimal = FALSE; /* true if fast parse saw a decimal point. */
-    if((fImpl->isParseFastpath()) && !fImpl->fMonetary &&
-       text.length()>0 &&
-       text.length()<32 &&
-       (posPrefix==NULL||posPrefix->isEmpty()) &&
-       (posSuffix==NULL||posSuffix->isEmpty()) &&
-       //            (negPrefix==NULL||negPrefix->isEmpty()) &&
-       //            (negSuffix==NULL||(negSuffix->isEmpty()) ) &&
-       TRUE) {  // optimized path
-      int j=position;
-      int l=text.length();
-      int digitCount=0;
-      UChar32 ch = text.char32At(j);
-      const UnicodeString *decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
-      UChar32 decimalChar = 0;
-      UBool intOnly = FALSE;
-      UChar32 lookForGroup = (groupingUsed&&intOnly&&strictParse)?groupingChar:0;
-
-      int32_t decimalCount = decimalString->countChar32(0,3);
-      if(isParseIntegerOnly()) {
-        decimalChar = 0; // not allowed
-        intOnly = TRUE; // Don't look for decimals.
-      } else if(decimalCount==1) {
-        decimalChar = decimalString->char32At(0); // Look for this decimal
-      } else if(decimalCount==0) {
-        decimalChar=0; // NO decimal set
-      } else {
-        j=l+1;//Set counter to end of line, so that we break. Unknown decimal situation.
-      }
-
-#ifdef FMT_DEBUG
-      printf("Preparing to do fastpath parse: decimalChar=U+%04X, groupingChar=U+%04X, first ch=U+%04X intOnly=%c strictParse=%c\n",
-        decimalChar, groupingChar, ch,
-        (intOnly)?'y':'n',
-        (strictParse)?'y':'n');
-#endif
-      if(ch==0x002D) { // '-'
-        j=l+1;//=break - negative number.
-
-        /*
-          parsedNum.append('-',err);
-          j+=U16_LENGTH(ch);
-          if(j<l) ch = text.char32At(j);
-        */
-      } else {
-        parsedNum.append('+',err);
-      }
-      while(j<l) {
-        int32_t digit = ch - zero;
-        if(digit >=0 && digit <= 9) {
-          parsedNum.append((char)(digit + '0'), err);
-          if((digitCount>0) || digit!=0 || j==(l-1)) {
-            digitCount++;
-          }
-        } else if(ch == 0) { // break out
-          digitCount=-1;
-          break;
-        } else if(ch == decimalChar) {
-          parsedNum.append((char)('.'), err);
-          decimalChar=0; // no more decimals.
-          // fastParseHadDecimal=TRUE;
-        } else if(ch == lookForGroup) {
-          // ignore grouping char. No decimals, so it has to be an ignorable grouping sep
-        } else if(intOnly && (lookForGroup!=0) && !u_isdigit(ch)) {
-          // parsing integer only and can fall through
-        } else {
-          digitCount=-1; // fail - fall through to slow parse
-          break;
-        }
-        j+=U16_LENGTH(ch);
-        ch = text.char32At(j); // for next
-      }
-      if(
-         ((j==l)||intOnly) // end OR only parsing integer
-         && (digitCount>0)) { // and have at least one digit
-        fastParseOk=true; // Fast parse OK!
-
-#ifdef SKIP_OPT
-        debug("SKIP_OPT");
-        /* for testing, try it the slow way. also */
-        fastParseOk=false;
-        parsedNum.clear();
-#else
-        parsePosition.setIndex(position=j);
-        status[fgStatusInfinite]=false;
-#endif
-      } else {
-        // was not OK. reset, retry
-#ifdef FMT_DEBUG
-        printf("Fall through: j=%d, l=%d, digitCount=%d\n", j, l, digitCount);
-#endif
-        parsedNum.clear();
-      }
-    } else {
-#ifdef FMT_DEBUG
-      printf("Could not fastpath parse. ");
-      printf("text.length()=%d ", text.length());
-      printf("posPrefix=%p posSuffix=%p ", posPrefix, posSuffix);
+DecimalFormat& DecimalFormat::operator=(const DecimalFormat& rhs) {
+    *fields->properties = *rhs.fields->properties;
+    fields->exportedProperties->clear();
+    fields->symbols.adoptInstead(new DecimalFormatSymbols(*rhs.fields->symbols));
+    touchNoError();
+    return *this;
+}
 
-      printf("\n");
-#endif
-    }
+DecimalFormat::~DecimalFormat() {
+    delete fields->atomicParser.exchange(nullptr);
+    delete fields->atomicCurrencyParser.exchange(nullptr);
+	delete fields;
+}
 
-  UnicodeString formatPattern;
-  toPattern(formatPattern);
+Format* DecimalFormat::clone() const {
+    return new DecimalFormat(*this);
+}
 
-  if(!fastParseOk
-#if UCONFIG_HAVE_PARSEALLINPUT
-     && fParseAllInput!=UNUM_YES
-#endif
-     )
-  {
-    int32_t formatWidth = fImpl->getOldFormatWidth();
-    // Match padding before prefix
-    if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
-        position = skipPadding(text, position);
-    }
-
-    // Match positive and negative prefixes; prefer longest match.
-    int32_t posMatch = compareAffix(text, position, FALSE, TRUE, posPrefix, complexCurrencyParsing, type, currency);
-    int32_t negMatch = compareAffix(text, position, TRUE,  TRUE, negPrefix, complexCurrencyParsing, type, currency);
-    if (posMatch >= 0 && negMatch >= 0) {
-        if (posMatch > negMatch) {
-            negMatch = -1;
-        } else if (negMatch > posMatch) {
-            posMatch = -1;
-        }
-    }
-    if (posMatch >= 0) {
-        position += posMatch;
-        parsedNum.append('+', err);
-    } else if (negMatch >= 0) {
-        position += negMatch;
-        parsedNum.append('-', err);
-    } else if (strictParse){
-        parsePosition.setErrorIndex(position);
-        return FALSE;
-    } else {
-        // Temporary set positive. This might be changed after checking suffix
-        parsedNum.append('+', err);
+UBool DecimalFormat::operator==(const Format& other) const {
+    auto* otherDF = dynamic_cast<const DecimalFormat*>(&other);
+    if (otherDF == nullptr) {
+        return false;
     }
+    return *fields->properties == *otherDF->fields->properties && *fields->symbols == *otherDF->fields->symbols;
+}
 
-    // Match padding before prefix
-    if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
-        position = skipPadding(text, position);
+UnicodeString& DecimalFormat::format(double number, UnicodeString& appendTo, FieldPosition& pos) const {
+    if (pos.getField() == FieldPosition::DONT_CARE && fastFormatDouble(number, appendTo)) {
+        return appendTo;
     }
+    UErrorCode localStatus = U_ZERO_ERROR;
+    FormattedNumber output = fields->formatter->formatDouble(number, localStatus);
+    fieldPositionHelper(output, pos, appendTo.length(), localStatus);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    if (! strictParse) {
-        position = skipUWhiteSpace(text, position);
+UnicodeString& DecimalFormat::format(double number, UnicodeString& appendTo, FieldPosition& pos,
+                                     UErrorCode& status) const {
+    if (pos.getField() == FieldPosition::DONT_CARE && fastFormatDouble(number, appendTo)) {
+        return appendTo;
     }
+    FormattedNumber output = fields->formatter->formatDouble(number, status);
+    fieldPositionHelper(output, pos, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    // process digits or Inf, find decimal position
-    const UnicodeString *inf = &fImpl->getConstSymbol(DecimalFormatSymbols::kInfinitySymbol);
-    int32_t infLen = (text.compare(position, inf->length(), *inf)
-        ? 0 : inf->length());
-    position += infLen; // infLen is non-zero when it does equal to infinity
-    status[fgStatusInfinite] = infLen != 0;
-
-    if (infLen != 0) {
-        parsedNum.append("Infinity", err);
-    } else {
-        // We now have a string of digits, possibly with grouping symbols,
-        // and decimal points.  We want to process these into a DigitList.
-        // We don't want to put a bunch of leading zeros into the DigitList
-        // though, so we keep track of the location of the decimal point,
-        // put only significant digits into the DigitList, and adjust the
-        // exponent as needed.
-
-
-        UBool strictFail = FALSE; // did we exit with a strict parse failure?
-        int32_t lastGroup = -1; // after which digit index did we last see a grouping separator?
-        int32_t currGroup = -1; // for temporary storage the digit index of the current grouping separator
-        int32_t gs2 = fImpl->fEffGrouping.fGrouping2 == 0 ? fImpl->fEffGrouping.fGrouping : fImpl->fEffGrouping.fGrouping2;
-
-        const UnicodeString *decimalString;
-        if (fImpl->fMonetary) {
-            decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol);
-        } else {
-            decimalString = &fImpl->getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
-        }
-        UChar32 decimalChar = decimalString->char32At(0);
-        int32_t decimalStringLength = decimalString->length();
-        int32_t decimalCharLength   = U16_LENGTH(decimalChar);
-
-        UBool sawDecimal = FALSE;
-        UChar32 sawDecimalChar = 0xFFFF;
-        UBool sawGrouping = FALSE;
-        UChar32 sawGroupingChar = 0xFFFF;
-        UBool sawDigit = FALSE;
-        int32_t backup = -1;
-        int32_t digit;
-
-        // equivalent grouping and decimal support
-        const UnicodeSet *decimalSet = NULL;
-        const UnicodeSet *groupingSet = NULL;
-
-        if (decimalCharLength == decimalStringLength) {
-            decimalSet = DecimalFormatStaticSets::getSimilarDecimals(decimalChar, strictParse);
-        }
-
-        if (groupingCharLength == groupingStringLength) {
-            if (strictParse) {
-                groupingSet = fStaticSets->fStrictDefaultGroupingSeparators;
-            } else {
-                groupingSet = fStaticSets->fDefaultGroupingSeparators;
-            }
-        }
-
-        // We need to test groupingChar and decimalChar separately from groupingSet and decimalSet, if the sets are even initialized.
-        // If sawDecimal is TRUE, only consider sawDecimalChar and NOT decimalSet
-        // If a character matches decimalSet, don't consider it to be a member of the groupingSet.
-
-        // We have to track digitCount ourselves, because digits.fCount will
-        // pin when the maximum allowable digits is reached.
-        int32_t digitCount = 0;
-        int32_t integerDigitCount = 0;
-
-        for (; position < textLength; )
-        {
-            UChar32 ch = text.char32At(position);
-
-            /* We recognize all digit ranges, not only the Latin digit range
-             * '0'..'9'.  We do so by using the Character.digit() method,
-             * which converts a valid Unicode digit to the range 0..9.
-             *
-             * The character 'ch' may be a digit.  If so, place its value
-             * from 0 to 9 in 'digit'.  First try using the locale digit,
-             * which may or MAY NOT be a standard Unicode digit range.  If
-             * this fails, try using the standard Unicode digit ranges by
-             * calling Character.digit().  If this also fails, digit will
-             * have a value outside the range 0..9.
-             */
-            digit = ch - zero;
-            if (digit < 0 || digit > 9)
-            {
-                digit = u_charDigitValue(ch);
-            }
-
-            // As a last resort, look through the localized digits if the zero digit
-            // is not a "standard" Unicode digit.
-            if ( (digit < 0 || digit > 9) && u_charDigitValue(zero) != 0) {
-                digit = 0;
-                if ( fImpl->getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)(DecimalFormatSymbols::kZeroDigitSymbol)).char32At(0) == ch ) {
-                    break;
-                }
-                for (digit = 1 ; digit < 10 ; digit++ ) {
-                    if ( fImpl->getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)(DecimalFormatSymbols::kOneDigitSymbol+digit-1)).char32At(0) == ch ) {
-                        break;
-                    }
-                }
-            }
-
-            if (digit >= 0 && digit <= 9)
-            {
-                if (strictParse && backup != -1) {
-                    // comma followed by digit, so group before comma is a
-                    // secondary group.  If there was a group separator
-                    // before that, the group must == the secondary group
-                    // length, else it can be <= the the secondary group
-                    // length.
-                    if ((lastGroup != -1 && currGroup - lastGroup != gs2) ||
-                        (lastGroup == -1 && digitCount - 1 > gs2)) {
-                        strictFail = TRUE;
-                        break;
-                    }
-
-                    lastGroup = currGroup;
-                }
-
-                // Cancel out backup setting (see grouping handler below)
-                currGroup = -1;
-                backup = -1;
-                sawDigit = TRUE;
-
-                // Note: this will append leading zeros
-                parsedNum.append((char)(digit + '0'), err);
-
-                // count any digit that's not a leading zero
-                if (digit > 0 || digitCount > 0 || sawDecimal) {
-                    digitCount += 1;
-
-                    // count any integer digit that's not a leading zero
-                    if (! sawDecimal) {
-                        integerDigitCount += 1;
-                    }
-                }
-
-                position += U16_LENGTH(ch);
-            }
-            else if (groupingStringLength > 0 &&
-                matchGrouping(groupingChar, sawGrouping, sawGroupingChar, groupingSet,
-                            decimalChar, decimalSet,
-                            ch) && groupingUsed)
-            {
-                if (sawDecimal) {
-                    break;
-                }
-
-                if (strictParse) {
-                    if ((!sawDigit || backup != -1)) {
-                        // leading group, or two group separators in a row
-                        strictFail = TRUE;
-                        break;
-                    }
-                }
-
-                // Ignore grouping characters, if we are using them, but require
-                // that they be followed by a digit.  Otherwise we backup and
-                // reprocess them.
-                currGroup = digitCount;
-                backup = position;
-                position += groupingStringLength;
-                sawGrouping=TRUE;
-                // Once we see a grouping character, we only accept that grouping character from then on.
-                sawGroupingChar=ch;
-            }
-            else if (matchDecimal(decimalChar,sawDecimal,sawDecimalChar, decimalSet, ch))
-            {
-                if (strictParse) {
-                    if (backup != -1 ||
-                        (lastGroup != -1 && digitCount - lastGroup != fImpl->fEffGrouping.fGrouping)) {
-                        strictFail = TRUE;
-                        break;
-                    }
-                }
-
-                // If we're only parsing integers, or if we ALREADY saw the
-                // decimal, then don't parse this one.
-                if (isParseIntegerOnly() || sawDecimal) {
-                    break;
-                }
-
-                parsedNum.append('.', err);
-                position += decimalStringLength;
-                sawDecimal = TRUE;
-                // Once we see a decimal character, we only accept that decimal character from then on.
-                sawDecimalChar=ch;
-                // decimalSet is considered to consist of (ch,ch)
-            }
-            else {
-
-                if(!fBoolFlags.contains(UNUM_PARSE_NO_EXPONENT) || // don't parse if this is set unless..
-                   isScientificNotation()) { // .. it's an exponent format - ignore setting and parse anyways
-                    const UnicodeString *tmp;
-                    tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kExponentialSymbol);
-                    // TODO: CASE
-                    if (!text.caseCompare(position, tmp->length(), *tmp, U_FOLD_CASE_DEFAULT))    // error code is set below if !sawDigit
-                    {
-                        // Parse sign, if present
-                        int32_t pos = position + tmp->length();
-                        char exponentSign = '+';
-
-                        if (pos < textLength)
-                        {
-                            tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
-                            if (!text.compare(pos, tmp->length(), *tmp))
-                            {
-                                pos += tmp->length();
-                            }
-                            else {
-                                tmp = &fImpl->getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
-                                if (!text.compare(pos, tmp->length(), *tmp))
-                                {
-                                    exponentSign = '-';
-                                    pos += tmp->length();
-                                }
-                            }
-                        }
-
-                        UBool sawExponentDigit = FALSE;
-                        while (pos < textLength) {
-                            ch = text.char32At(pos);
-                            digit = ch - zero;
-
-                            if (digit < 0 || digit > 9) {
-                                digit = u_charDigitValue(ch);
-                            }
-                            if (0 <= digit && digit <= 9) {
-                                if (!sawExponentDigit) {
-                                    parsedNum.append('E', err);
-                                    parsedNum.append(exponentSign, err);
-                                    sawExponentDigit = TRUE;
-                                }
-                                pos += U16_LENGTH(ch);
-                                parsedNum.append((char)(digit + '0'), err);
-                            } else {
-                                break;
-                            }
-                        }
-
-                        if (sawExponentDigit) {
-                            position = pos; // Advance past the exponent
-                        }
-
-                        break; // Whether we fail or succeed, we exit this loop
-                    } else {
-                        break;
-                    }
-                } else { // not parsing exponent
-                    break;
-              }
-            }
-        }
-
-        // if we didn't see a decimal and it is required, check to see if the pattern had one
-        if(!sawDecimal && isDecimalPatternMatchRequired())
-        {
-            if(formatPattern.indexOf(kPatternDecimalSeparator) != -1)
-            {
-                parsePosition.setIndex(oldStart);
-                parsePosition.setErrorIndex(position);
-                debug("decimal point match required fail!");
-                return FALSE;
-            }
-        }
-
-        if (backup != -1)
-        {
-            position = backup;
-        }
-
-        if (strictParse && !sawDecimal) {
-            if (lastGroup != -1 && digitCount - lastGroup != fImpl->fEffGrouping.fGrouping) {
-                strictFail = TRUE;
-            }
-        }
+UnicodeString&
+DecimalFormat::format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                      UErrorCode& status) const {
+    if (posIter == nullptr && fastFormatDouble(number, appendTo)) {
+        return appendTo;
+    }
+    FormattedNumber output = fields->formatter->formatDouble(number, status);
+    fieldPositionIteratorHelper(output, posIter, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-        if (strictFail) {
-            // only set with strictParse and a grouping separator error
+UnicodeString& DecimalFormat::format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const {
+    return format(static_cast<int64_t> (number), appendTo, pos);
+}
 
-            parsePosition.setIndex(oldStart);
-            parsePosition.setErrorIndex(position);
-            debug("strictFail!");
-            return FALSE;
-        }
+UnicodeString& DecimalFormat::format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
+                                     UErrorCode& status) const {
+    return format(static_cast<int64_t> (number), appendTo, pos, status);
+}
 
-        // If there was no decimal point we have an integer
+UnicodeString&
+DecimalFormat::format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                      UErrorCode& status) const {
+    return format(static_cast<int64_t> (number), appendTo, posIter, status);
+}
 
-        // If none of the text string was recognized.  For example, parse
-        // "x" with pattern "#0.00" (return index and error index both 0)
-        // parse "$" with pattern "$#0.00". (return index 0 and error index
-        // 1).
-        if (!sawDigit && digitCount == 0) {
-#ifdef FMT_DEBUG
-            debug("none of text rec");
-            printf("position=%d\n",position);
-#endif
-            parsePosition.setIndex(oldStart);
-            parsePosition.setErrorIndex(oldStart);
-            return FALSE;
-        }
+UnicodeString& DecimalFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const {
+    if (pos.getField() == FieldPosition::DONT_CARE && fastFormatInt64(number, appendTo)) {
+        return appendTo;
     }
+    UErrorCode localStatus = U_ZERO_ERROR;
+    FormattedNumber output = fields->formatter->formatInt(number, localStatus);
+    fieldPositionHelper(output, pos, appendTo.length(), localStatus);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    // Match padding before suffix
-    if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
-        position = skipPadding(text, position);
+UnicodeString& DecimalFormat::format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
+                                     UErrorCode& status) const {
+    if (pos.getField() == FieldPosition::DONT_CARE && fastFormatInt64(number, appendTo)) {
+        return appendTo;
     }
+    FormattedNumber output = fields->formatter->formatInt(number, status);
+    fieldPositionHelper(output, pos, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    int32_t posSuffixMatch = -1, negSuffixMatch = -1;
-
-    // Match positive and negative suffixes; prefer longest match.
-    if (posMatch >= 0 || (!strictParse && negMatch < 0)) {
-        posSuffixMatch = compareAffix(text, position, FALSE, FALSE, posSuffix, complexCurrencyParsing, type, currency);
-    }
-    if (negMatch >= 0) {
-        negSuffixMatch = compareAffix(text, position, TRUE, FALSE, negSuffix, complexCurrencyParsing, type, currency);
-    }
-    if (posSuffixMatch >= 0 && negSuffixMatch >= 0) {
-        if (posSuffixMatch > negSuffixMatch) {
-            negSuffixMatch = -1;
-        } else if (negSuffixMatch > posSuffixMatch) {
-            posSuffixMatch = -1;
-        }
+UnicodeString&
+DecimalFormat::format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                      UErrorCode& status) const {
+    if (posIter == nullptr && fastFormatInt64(number, appendTo)) {
+        return appendTo;
     }
+    FormattedNumber output = fields->formatter->formatInt(number, status);
+    fieldPositionIteratorHelper(output, posIter, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    // Fail if neither or both
-    if (strictParse && ((posSuffixMatch >= 0) == (negSuffixMatch >= 0))) {
-        parsePosition.setErrorIndex(position);
-        debug("neither or both");
-        return FALSE;
-    }
+UnicodeString&
+DecimalFormat::format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                      UErrorCode& status) const {
+    FormattedNumber output = fields->formatter->formatDecimal(number, status);
+    fieldPositionIteratorHelper(output, posIter, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    position += (posSuffixMatch >= 0 ? posSuffixMatch : (negSuffixMatch >= 0 ? negSuffixMatch : 0));
+UnicodeString& DecimalFormat::format(const DecimalQuantity& number, UnicodeString& appendTo,
+                                     FieldPositionIterator* posIter, UErrorCode& status) const {
+    FormattedNumber output = fields->formatter->formatDecimalQuantity(number, status);
+    fieldPositionIteratorHelper(output, posIter, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
 
-    // Match padding before suffix
-    if (formatWidth > 0 && fImpl->fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
-        position = skipPadding(text, position);
+UnicodeString&
+DecimalFormat::format(const DecimalQuantity& number, UnicodeString& appendTo, FieldPosition& pos,
+                      UErrorCode& status) const {
+    FormattedNumber output = fields->formatter->formatDecimalQuantity(number, status);
+    fieldPositionHelper(output, pos, appendTo.length(), status);
+    auto appendable = UnicodeStringAppendable(appendTo);
+    output.appendTo(appendable);
+    return appendTo;
+}
+
+void DecimalFormat::parse(const UnicodeString& text, Formattable& output,
+                          ParsePosition& parsePosition) const {
+    if (parsePosition.getIndex() < 0 || parsePosition.getIndex() >= text.length()) {
+        return;
     }
 
-    parsePosition.setIndex(position);
-
-    parsedNum.data()[0] = (posSuffixMatch >= 0 || (!strictParse && negMatch < 0 && negSuffixMatch < 0)) ? '+' : '-';
-#ifdef FMT_DEBUG
-printf("PP -> %d, SLOW = [%s]!    pp=%d, os=%d, err=%s\n", position, parsedNum.data(), parsePosition.getIndex(),oldStart,u_errorName(err));
-#endif
-  } /* end SLOW parse */
-  if(parsePosition.getIndex() == oldStart)
-    {
-#ifdef FMT_DEBUG
-      printf(" PP didnt move, err\n");
-#endif
-        parsePosition.setErrorIndex(position);
-        return FALSE;
-    }
-#if UCONFIG_HAVE_PARSEALLINPUT
-  else if (fParseAllInput==UNUM_YES&&parsePosition.getIndex()!=textLength)
-    {
-#ifdef FMT_DEBUG
-      printf(" PP didnt consume all (UNUM_YES), err\n");
-#endif
-        parsePosition.setErrorIndex(position);
-        return FALSE;
-    }
-#endif
-    // uint32_t bits = (fastParseOk?kFastpathOk:0) |
-    //   (fastParseHadDecimal?0:kNoDecimal);
-    //printf("FPOK=%d, FPHD=%d, bits=%08X\n", fastParseOk, fastParseHadDecimal, bits);
-    digits.set(parsedNum.toStringPiece(),
-               err,
-               0//bits
-               );
-
-    if (U_FAILURE(err)) {
-#ifdef FMT_DEBUG
-      printf(" err setting %s\n", u_errorName(err));
-#endif
-        parsePosition.setErrorIndex(position);
-        return FALSE;
-    }
-
-    // check if we missed a required decimal point
-    if(fastParseOk && isDecimalPatternMatchRequired())
-    {
-        if(formatPattern.indexOf(kPatternDecimalSeparator) != -1)
-        {
-            parsePosition.setIndex(oldStart);
-            parsePosition.setErrorIndex(position);
-            debug("decimal point match required fail!");
-            return FALSE;
-        }
+    ErrorCode status;
+    ParsedNumber result;
+    // Note: if this is a currency instance, currencies will be matched despite the fact that we are not in the
+    // parseCurrency method (backwards compatibility)
+    int32_t startIndex = parsePosition.getIndex();
+    const NumberParserImpl* parser = getParser(status);
+    if (U_FAILURE(status)) { return; }
+    parser->parse(text, startIndex, true, result, status);
+    // TODO: Do we need to check for fImpl->properties->parseAllInput (UCONFIG_HAVE_PARSEALLINPUT) here?
+    if (result.success()) {
+        parsePosition.setIndex(result.charEnd);
+        result.populateFormattable(output, parser->getParseFlags());
+    } else {
+        parsePosition.setErrorIndex(startIndex + result.charEnd);
     }
+}
 
-
-    return TRUE;
-}
-
-/**
- * Starting at position, advance past a run of pad characters, if any.
- * Return the index of the first character after position that is not a pad
- * character.  Result is >= position.
- */
-int32_t DecimalFormat::skipPadding(const UnicodeString& text, int32_t position) const {
-    int32_t padLen = U16_LENGTH(fImpl->fAffixes.fPadChar);
-    while (position < text.length() &&
-           text.char32At(position) == fImpl->fAffixes.fPadChar) {
-        position += padLen;
-    }
-    return position;
-}
-
-/**
- * Return the length matched by the given affix, or -1 if none.
- * Runs of white space in the affix, match runs of white space in
- * the input.  Pattern white space and input white space are
- * determined differently; see code.
- * @param text input text
- * @param pos offset into input at which to begin matching
- * @param isNegative
- * @param isPrefix
- * @param affixPat affix pattern used for currency affix comparison.
- * @param complexCurrencyParsing whether it is currency parsing or not
- * @param type the currency type to parse against, LONG_NAME only or not.
- * @param currency return value for parsed currency, for generic
- * currency parsing mode, or null for normal parsing. In generic
- * currency parsing mode, any currency is parsed, not just the
- * currency that this formatter is set to.
- * @return length of input that matches, or -1 if match failure
- */
-int32_t DecimalFormat::compareAffix(const UnicodeString& text,
-                                    int32_t pos,
-                                    UBool isNegative,
-                                    UBool isPrefix,
-                                    const UnicodeString* affixPat,
-                                    UBool complexCurrencyParsing,
-                                    int8_t type,
-                                    UChar* currency) const
-{
-    const UnicodeString *patternToCompare;
-    if (currency != NULL ||
-        (fImpl->fMonetary && complexCurrencyParsing)) {
-
-        if (affixPat != NULL) {
-            return compareComplexAffix(*affixPat, text, pos, type, currency);
-        }
+CurrencyAmount* DecimalFormat::parseCurrency(const UnicodeString& text, ParsePosition& parsePosition) const {
+    if (parsePosition.getIndex() < 0 || parsePosition.getIndex() >= text.length()) {
+        return nullptr;
     }
 
-    if (isNegative) {
-        if (isPrefix) {
-            patternToCompare = &fImpl->fAffixes.fNegativePrefix.getOtherVariant().toString();
-        }
-        else {
-            patternToCompare = &fImpl->fAffixes.fNegativeSuffix.getOtherVariant().toString();
-        }
-    }
-    else {
-        if (isPrefix) {
-            patternToCompare = &fImpl->fAffixes.fPositivePrefix.getOtherVariant().toString();
-        }
-        else {
-            patternToCompare = &fImpl->fAffixes.fPositiveSuffix.getOtherVariant().toString();
-        }
+    ErrorCode status;
+    ParsedNumber result;
+    // Note: if this is a currency instance, currencies will be matched despite the fact that we are not in the
+    // parseCurrency method (backwards compatibility)
+    int32_t startIndex = parsePosition.getIndex();
+    const NumberParserImpl* parser = getCurrencyParser(status);
+    if (U_FAILURE(status)) { return nullptr; }
+    parser->parse(text, startIndex, true, result, status);
+    // TODO: Do we need to check for fImpl->properties->parseAllInput (UCONFIG_HAVE_PARSEALLINPUT) here?
+    if (result.success()) {
+        parsePosition.setIndex(result.charEnd);
+        Formattable formattable;
+        result.populateFormattable(formattable, parser->getParseFlags());
+        return new CurrencyAmount(formattable, result.currencyCode, status);
+    } else {
+        parsePosition.setErrorIndex(startIndex + result.charEnd);
+        return nullptr;
     }
-    return compareSimpleAffix(*patternToCompare, text, pos, isLenient());
 }
 
-UBool DecimalFormat::equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const {
-    if (lhs == rhs) {
-        return TRUE;
-    }
-    U_ASSERT(fStaticSets != NULL); // should already be loaded
-    const UnicodeSet *minusSigns = fStaticSets->fMinusSigns;
-    const UnicodeSet *plusSigns = fStaticSets->fPlusSigns;
-    return (minusSigns->contains(lhs) && minusSigns->contains(rhs)) ||
-        (plusSigns->contains(lhs) && plusSigns->contains(rhs));
+const DecimalFormatSymbols* DecimalFormat::getDecimalFormatSymbols(void) const {
+    return fields->symbols.getAlias();
 }
 
-// check for LRM 0x200E, RLM 0x200F, ALM 0x061C
-#define IS_BIDI_MARK(c) (c==0x200E || c==0x200F || c==0x061C)
+void DecimalFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt) {
+    if (symbolsToAdopt == nullptr) {
+        return; // do not allow caller to set fields->symbols to NULL
+    }
+    fields->symbols.adoptInstead(symbolsToAdopt);
+    touchNoError();
+}
 
-#define TRIM_BUFLEN 32
-UnicodeString& DecimalFormat::trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix) {
-    UChar trimBuf[TRIM_BUFLEN];
-    int32_t affixLen = affix.length();
-    int32_t affixPos, trimLen = 0;
+void DecimalFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols) {
+    fields->symbols.adoptInstead(new DecimalFormatSymbols(symbols));
+    touchNoError();
+}
 
-    for (affixPos = 0; affixPos < affixLen; affixPos++) {
-        UChar c = affix.charAt(affixPos);
-        if (!IS_BIDI_MARK(c)) {
-            if (trimLen < TRIM_BUFLEN) {
-                trimBuf[trimLen++] = c;
-            } else {
-                trimLen = 0;
-                break;
-            }
-        }
-    }
-    return (trimLen > 0)? trimmedAffix.setTo(trimBuf, trimLen): trimmedAffix.setTo(affix);
-}
-
-/**
- * Return the length matched by the given affix, or -1 if none.
- * Runs of white space in the affix, match runs of white space in
- * the input.  Pattern white space and input white space are
- * determined differently; see code.
- * @param affix pattern string, taken as a literal
- * @param input input text
- * @param pos offset into input at which to begin matching
- * @return length of input that matches, or -1 if match failure
- */
-int32_t DecimalFormat::compareSimpleAffix(const UnicodeString& affix,
-                                          const UnicodeString& input,
-                                          int32_t pos,
-                                          UBool lenient) const {
-    int32_t start = pos;
-    UnicodeString trimmedAffix;
-    // For more efficiency we should keep lazily-created trimmed affixes around in
-    // instance variables instead of trimming each time they are used (the next step)
-    trimMarksFromAffix(affix, trimmedAffix);
-    UChar32 affixChar = trimmedAffix.char32At(0);
-    int32_t affixLength = trimmedAffix.length();
-    int32_t inputLength = input.length();
-    int32_t affixCharLength = U16_LENGTH(affixChar);
-    UnicodeSet *affixSet;
-    UErrorCode status = U_ZERO_ERROR;
-
-    U_ASSERT(fStaticSets != NULL); // should already be loaded
+const CurrencyPluralInfo* DecimalFormat::getCurrencyPluralInfo(void) const {
+    return fields->properties->currencyPluralInfo.fPtr.getAlias();
+}
 
-    if (U_FAILURE(status)) {
-        return -1;
-    }
-    if (!lenient) {
-        affixSet = fStaticSets->fStrictDashEquivalents;
-
-        // If the trimmedAffix is exactly one character long and that character
-        // is in the dash set and the very next input character is also
-        // in the dash set, return a match.
-        if (affixCharLength == affixLength && affixSet->contains(affixChar))  {
-            UChar32 ic = input.char32At(pos);
-            if (affixSet->contains(ic)) {
-                pos += U16_LENGTH(ic);
-                pos = skipBidiMarks(input, pos); // skip any trailing bidi marks
-                return pos - start;
-            }
-        }
+void DecimalFormat::adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt) {
+    fields->properties->currencyPluralInfo.fPtr.adoptInstead(toAdopt);
+    touchNoError();
+}
 
-        for (int32_t i = 0; i < affixLength; ) {
-            UChar32 c = trimmedAffix.char32At(i);
-            int32_t len = U16_LENGTH(c);
-            if (PatternProps::isWhiteSpace(c)) {
-                // We may have a pattern like: \u200F \u0020
-                //        and input text like: \u200F \u0020
-                // Note that U+200F and U+0020 are Pattern_White_Space but only
-                // U+0020 is UWhiteSpace.  So we have to first do a direct
-                // match of the run of Pattern_White_Space in the pattern,
-                // then match any extra characters.
-                UBool literalMatch = FALSE;
-                while (pos < inputLength) {
-                    UChar32 ic = input.char32At(pos);
-                    if (ic == c) {
-                        literalMatch = TRUE;
-                        i += len;
-                        pos += len;
-                        if (i == affixLength) {
-                            break;
-                        }
-                        c = trimmedAffix.char32At(i);
-                        len = U16_LENGTH(c);
-                        if (!PatternProps::isWhiteSpace(c)) {
-                            break;
-                        }
-                    } else if (IS_BIDI_MARK(ic)) {
-                        pos ++; // just skip over this input text
-                    } else {
-                        break;
-                    }
-                }
-
-                // Advance over run in pattern
-                i = skipPatternWhiteSpace(trimmedAffix, i);
-
-                // Advance over run in input text
-                // Must see at least one white space char in input,
-                // unless we've already matched some characters literally.
-                int32_t s = pos;
-                pos = skipUWhiteSpace(input, pos);
-                if (pos == s && !literalMatch) {
-                    return -1;
-                }
-
-                // If we skip UWhiteSpace in the input text, we need to skip it in the pattern.
-                // Otherwise, the previous lines may have skipped over text (such as U+00A0) that
-                // is also in the trimmedAffix.
-                i = skipUWhiteSpace(trimmedAffix, i);
-            } else {
-                UBool match = FALSE;
-                while (pos < inputLength) {
-                    UChar32 ic = input.char32At(pos);
-                    if (!match && ic == c) {
-                        i += len;
-                        pos += len;
-                        match = TRUE;
-                    } else if (IS_BIDI_MARK(ic)) {
-                        pos++; // just skip over this input text
-                    } else {
-                        break;
-                    }
-                }
-                if (!match) {
-                    return -1;
-                }
-            }
-        }
+void DecimalFormat::setCurrencyPluralInfo(const CurrencyPluralInfo& info) {
+    if (fields->properties->currencyPluralInfo.fPtr.isNull()) {
+        fields->properties->currencyPluralInfo.fPtr.adoptInstead(info.clone());
     } else {
-        UBool match = FALSE;
+        *fields->properties->currencyPluralInfo.fPtr = info; // copy-assignment operator
+    }
+    touchNoError();
+}
 
-        affixSet = fStaticSets->fDashEquivalents;
+UnicodeString& DecimalFormat::getPositivePrefix(UnicodeString& result) const {
+    ErrorCode localStatus;
+    fields->formatter->getAffixImpl(true, false, result, localStatus);
+    return result;
+}
 
-        if (affixCharLength == affixLength && affixSet->contains(affixChar))  {
-            pos = skipUWhiteSpaceAndMarks(input, pos);
-            UChar32 ic = input.char32At(pos);
+void DecimalFormat::setPositivePrefix(const UnicodeString& newValue) {
+    if (newValue == fields->properties->positivePrefix) { return; }
+    fields->properties->positivePrefix = newValue;
+    touchNoError();
+}
 
-            if (affixSet->contains(ic)) {
-                pos += U16_LENGTH(ic);
-                pos = skipBidiMarks(input, pos);
-                return pos - start;
-            }
-        }
+UnicodeString& DecimalFormat::getNegativePrefix(UnicodeString& result) const {
+    ErrorCode localStatus;
+    fields->formatter->getAffixImpl(true, true, result, localStatus);
+    return result;
+}
 
-        for (int32_t i = 0; i < affixLength; )
-        {
-            //i = skipRuleWhiteSpace(trimmedAffix, i);
-            i = skipUWhiteSpace(trimmedAffix, i);
-            pos = skipUWhiteSpaceAndMarks(input, pos);
+void DecimalFormat::setNegativePrefix(const UnicodeString& newValue) {
+    if (newValue == fields->properties->negativePrefix) { return; }
+    fields->properties->negativePrefix = newValue;
+    touchNoError();
+}
 
-            if (i >= affixLength || pos >= inputLength) {
-                break;
-            }
+UnicodeString& DecimalFormat::getPositiveSuffix(UnicodeString& result) const {
+    ErrorCode localStatus;
+    fields->formatter->getAffixImpl(false, false, result, localStatus);
+    return result;
+}
 
-            UChar32 c = trimmedAffix.char32At(i);
-            UChar32 ic = input.char32At(pos);
+void DecimalFormat::setPositiveSuffix(const UnicodeString& newValue) {
+    if (newValue == fields->properties->positiveSuffix) { return; }
+    fields->properties->positiveSuffix = newValue;
+    touchNoError();
+}
 
-            if (!equalWithSignCompatibility(ic, c)) {
-                return -1;
-            }
+UnicodeString& DecimalFormat::getNegativeSuffix(UnicodeString& result) const {
+    ErrorCode localStatus;
+    fields->formatter->getAffixImpl(false, true, result, localStatus);
+    return result;
+}
 
-            match = TRUE;
-            i += U16_LENGTH(c);
-            pos += U16_LENGTH(ic);
-            pos = skipBidiMarks(input, pos);
-        }
+void DecimalFormat::setNegativeSuffix(const UnicodeString& newValue) {
+    if (newValue == fields->properties->negativeSuffix) { return; }
+    fields->properties->negativeSuffix = newValue;
+    touchNoError();
+}
 
-        if (affixLength > 0 && ! match) {
-            return -1;
-        }
-    }
-    return pos - start;
+UBool DecimalFormat::isSignAlwaysShown() const {
+    return fields->properties->signAlwaysShown;
 }
 
-/**
- * Skip over a run of zero or more Pattern_White_Space characters at
- * pos in text.
- */
-int32_t DecimalFormat::skipPatternWhiteSpace(const UnicodeString& text, int32_t pos) {
-    const UChar* s = text.getBuffer();
-    return (int32_t)(PatternProps::skipWhiteSpace(s + pos, text.length() - pos) - s);
+void DecimalFormat::setSignAlwaysShown(UBool value) {
+    if (UBOOL_TO_BOOL(value) == fields->properties->signAlwaysShown) { return; }
+    fields->properties->signAlwaysShown = value;
+    touchNoError();
 }
 
-/**
- * Skip over a run of zero or more isUWhiteSpace() characters at pos
- * in text.
- */
-int32_t DecimalFormat::skipUWhiteSpace(const UnicodeString& text, int32_t pos) {
-    while (pos < text.length()) {
-        UChar32 c = text.char32At(pos);
-        if (!u_isUWhiteSpace(c)) {
-            break;
-        }
-        pos += U16_LENGTH(c);
+int32_t DecimalFormat::getMultiplier(void) const {
+    if (fields->properties->multiplier != 1) {
+        return fields->properties->multiplier;
+    } else if (fields->properties->magnitudeMultiplier != 0) {
+        return static_cast<int32_t>(uprv_pow10(fields->properties->magnitudeMultiplier));
+    } else {
+        return 1;
     }
-    return pos;
 }
 
-/**
- * Skip over a run of zero or more isUWhiteSpace() characters or bidi marks at pos
- * in text.
- */
-int32_t DecimalFormat::skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos) {
-    while (pos < text.length()) {
-        UChar32 c = text.char32At(pos);
-        if (!u_isUWhiteSpace(c) && !IS_BIDI_MARK(c)) { // u_isUWhiteSpace doesn't include LRM,RLM,ALM
-            break;
-        }
-        pos += U16_LENGTH(c);
+void DecimalFormat::setMultiplier(int32_t multiplier) {
+    if (multiplier == 0) {
+        multiplier = 1;     // one being the benign default value for a multiplier.
     }
-    return pos;
-}
 
-/**
- * Skip over a run of zero or more bidi marks at pos in text.
- */
-int32_t DecimalFormat::skipBidiMarks(const UnicodeString& text, int32_t pos) {
-    while (pos < text.length()) {
-        UChar c = text.charAt(pos);
-        if (!IS_BIDI_MARK(c)) {
+    // Try to convert to a magnitude multiplier first
+    int delta = 0;
+    int value = multiplier;
+    while (value != 1) {
+        delta++;
+        int temp = value / 10;
+        if (temp * 10 != value) {
+            delta = -1;
             break;
         }
-        pos++;
-    }
-    return pos;
-}
-
-/**
- * Return the length matched by the given affix, or -1 if none.
- * @param affixPat pattern string
- * @param input input text
- * @param pos offset into input at which to begin matching
- * @param type the currency type to parse against, LONG_NAME only or not.
- * @param currency return value for parsed currency, for generic
- * currency parsing mode, or null for normal parsing. In generic
- * currency parsing mode, any currency is parsed, not just the
- * currency that this formatter is set to.
- * @return length of input that matches, or -1 if match failure
- */
-int32_t DecimalFormat::compareComplexAffix(const UnicodeString& affixPat,
-                                           const UnicodeString& text,
-                                           int32_t pos,
-                                           int8_t type,
-                                           UChar* currency) const
-{
-    int32_t start = pos;
-    U_ASSERT(currency != NULL || fImpl->fMonetary);
-
-    for (int32_t i=0;
-         i<affixPat.length() && pos >= 0; ) {
-        UChar32 c = affixPat.char32At(i);
-        i += U16_LENGTH(c);
-
-        if (c == kQuote) {
-            U_ASSERT(i <= affixPat.length());
-            c = affixPat.char32At(i);
-            i += U16_LENGTH(c);
-
-            const UnicodeString* affix = NULL;
-
-            switch (c) {
-            case kCurrencySign: {
-                // since the currency names in choice format is saved
-                // the same way as other currency names,
-                // do not need to do currency choice parsing here.
-                // the general currency parsing parse against all names,
-                // including names in choice format.
-                UBool intl = i<affixPat.length() &&
-                    affixPat.char32At(i) == kCurrencySign;
-                if (intl) {
-                    ++i;
-                }
-                UBool plural = i<affixPat.length() &&
-                    affixPat.char32At(i) == kCurrencySign;
-                if (plural) {
-                    ++i;
-                    intl = FALSE;
-                }
-                // Parse generic currency -- anything for which we
-                // have a display name, or any 3-letter ISO code.
-                // Try to parse display name for our locale; first
-                // determine our locale.
-                const char* loc = fCurrencyPluralInfo->getLocale().getName();
-                ParsePosition ppos(pos);
-                UChar curr[4];
-                UErrorCode ec = U_ZERO_ERROR;
-                // Delegate parse of display name => ISO code to Currency
-                uprv_parseCurrency(loc, text, ppos, type, curr, ec);
-
-                // If parse succeeds, populate currency[0]
-                if (U_SUCCESS(ec) && ppos.getIndex() != pos) {
-                    if (currency) {
-                        u_strcpy(currency, curr);
-                    } else {
-                        // The formatter is currency-style but the client has not requested
-                        // the value of the parsed currency. In this case, if that value does
-                        // not match the formatter's current value, then the parse fails.
-                        UChar effectiveCurr[4];
-                        getEffectiveCurrency(effectiveCurr, ec);
-                        if ( U_FAILURE(ec) || u_strncmp(curr,effectiveCurr,4) != 0 ) {
-                            pos = -1;
-                            continue;
-                        }
-                    }
-                    pos = ppos.getIndex();
-                } else if (!isLenient()){
-                    pos = -1;
-                }
-                continue;
-            }
-            case kPatternPercent:
-                affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPercentSymbol);
-                break;
-            case kPatternPerMill:
-                affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPerMillSymbol);
-                break;
-            case kPatternPlus:
-                affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
-                break;
-            case kPatternMinus:
-                affix = &fImpl->getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
-                break;
-            default:
-                // fall through to affix!=0 test, which will fail
-                break;
-            }
-
-            if (affix != NULL) {
-                pos = match(text, pos, *affix);
-                continue;
-            }
-        }
-
-        pos = match(text, pos, c);
-        if (PatternProps::isWhiteSpace(c)) {
-            i = skipPatternWhiteSpace(affixPat, i);
-        }
+        value = temp;
     }
-    return pos - start;
-}
-
-/**
- * Match a single character at text[pos] and return the index of the
- * next character upon success.  Return -1 on failure.  If
- * ch is a Pattern_White_Space then match a run of white space in text.
- */
-int32_t DecimalFormat::match(const UnicodeString& text, int32_t pos, UChar32 ch) {
-    if (PatternProps::isWhiteSpace(ch)) {
-        // Advance over run of white space in input text
-        // Must see at least one white space char in input
-        int32_t s = pos;
-        pos = skipPatternWhiteSpace(text, pos);
-        if (pos == s) {
-            return -1;
-        }
-        return pos;
-    }
-    return (pos >= 0 && text.char32At(pos) == ch) ?
-        (pos + U16_LENGTH(ch)) : -1;
-}
-
-/**
- * Match a string at text[pos] and return the index of the next
- * character upon success.  Return -1 on failure.  Match a run of
- * white space in str with a run of white space in text.
- */
-int32_t DecimalFormat::match(const UnicodeString& text, int32_t pos, const UnicodeString& str) {
-    for (int32_t i=0; i<str.length() && pos >= 0; ) {
-        UChar32 ch = str.char32At(i);
-        i += U16_LENGTH(ch);
-        if (PatternProps::isWhiteSpace(ch)) {
-            i = skipPatternWhiteSpace(str, i);
-        }
-        pos = match(text, pos, ch);
-    }
-    return pos;
-}
-
-UBool DecimalFormat::matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
-                         UnicodeSet *sset, UChar32 schar)
-{
-    if (sset != NULL) {
-        return sset->contains(schar);
-    }
-
-    return text.compare(position, length, symbol) == 0;
-}
-
-UBool DecimalFormat::matchDecimal(UChar32 symbolChar,
-                            UBool sawDecimal,  UChar32 sawDecimalChar,
-                             const UnicodeSet *sset, UChar32 schar) {
-   if(sawDecimal) {
-       return schar==sawDecimalChar;
-   } else if(schar==symbolChar) {
-       return TRUE;
-   } else if(sset!=NULL) {
-        return sset->contains(schar);
-   } else {
-       return FALSE;
-   }
-}
-
-UBool DecimalFormat::matchGrouping(UChar32 groupingChar,
-                            UBool sawGrouping, UChar32 sawGroupingChar,
-                             const UnicodeSet *sset,
-                             UChar32 /*decimalChar*/, const UnicodeSet *decimalSet,
-                             UChar32 schar) {
-    if(sawGrouping) {
-        return schar==sawGroupingChar;  // previously found
-    } else if(schar==groupingChar) {
-        return TRUE; // char from symbols
-    } else if(sset!=NULL) {
-        return sset->contains(schar) &&  // in groupingSet but...
-           ((decimalSet==NULL) || !decimalSet->contains(schar)); // Exclude decimalSet from groupingSet
+    if (delta != -1) {
+        fields->properties->magnitudeMultiplier = delta;
+        fields->properties->multiplier = 1;
     } else {
-        return FALSE;
+        fields->properties->magnitudeMultiplier = 0;
+        fields->properties->multiplier = multiplier;
     }
+    touchNoError();
 }
 
+int32_t DecimalFormat::getMultiplierScale() const {
+    return fields->properties->multiplierScale;
+}
 
+void DecimalFormat::setMultiplierScale(int32_t newValue) {
+    if (newValue == fields->properties->multiplierScale) { return; }
+    fields->properties->multiplierScale = newValue;
+    touchNoError();
+}
 
-//------------------------------------------------------------------------------
-// Gets the pointer to the localized decimal format symbols
+double DecimalFormat::getRoundingIncrement(void) const {
+    return fields->exportedProperties->roundingIncrement;
+}
 
-const DecimalFormatSymbols*
-DecimalFormat::getDecimalFormatSymbols() const
-{
-    return &fImpl->getDecimalFormatSymbols();
+void DecimalFormat::setRoundingIncrement(double newValue) {
+    if (newValue == fields->properties->roundingIncrement) { return; }
+    fields->properties->roundingIncrement = newValue;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// De-owning the current localized symbols and adopt the new symbols.
+ERoundingMode DecimalFormat::getRoundingMode(void) const {
+    // UNumberFormatRoundingMode and ERoundingMode have the same values.
+    return static_cast<ERoundingMode>(fields->exportedProperties->roundingMode.getNoError());
+}
 
-void
-DecimalFormat::adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt)
-{
-    if (symbolsToAdopt == NULL) {
-        return; // do not allow caller to set fSymbols to NULL
+void DecimalFormat::setRoundingMode(ERoundingMode roundingMode) {
+    auto uRoundingMode = static_cast<UNumberFormatRoundingMode>(roundingMode);
+    if (!fields->properties->roundingMode.isNull() && uRoundingMode == fields->properties->roundingMode.getNoError()) {
+        return;
     }
-    fImpl->adoptDecimalFormatSymbols(symbolsToAdopt);
+    NumberFormat::setMaximumIntegerDigits(roundingMode); // to set field for compatibility
+    fields->properties->roundingMode = uRoundingMode;
+    touchNoError();
 }
-//------------------------------------------------------------------------------
-// Setting the symbols is equlivalent to adopting a newly created localized
-// symbols.
 
-void
-DecimalFormat::setDecimalFormatSymbols(const DecimalFormatSymbols& symbols)
-{
-    adoptDecimalFormatSymbols(new DecimalFormatSymbols(symbols));
+int32_t DecimalFormat::getFormatWidth(void) const {
+    return fields->properties->formatWidth;
 }
 
-
-const CurrencyPluralInfo*
-DecimalFormat::getCurrencyPluralInfo(void) const
-{
-    return fCurrencyPluralInfo;
+void DecimalFormat::setFormatWidth(int32_t width) {
+    if (width == fields->properties->formatWidth) { return; }
+    fields->properties->formatWidth = width;
+    touchNoError();
 }
 
-
-void
-DecimalFormat::adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt)
-{
-    if (toAdopt != NULL) {
-        delete fCurrencyPluralInfo;
-        fCurrencyPluralInfo = toAdopt;
-        // re-set currency affix patterns and currency affixes.
-        if (fImpl->fMonetary) {
-            UErrorCode status = U_ZERO_ERROR;
-            if (fAffixPatternsForCurrency) {
-                deleteHashForAffixPattern();
-            }
-            setupCurrencyAffixPatterns(status);
-        }
+UnicodeString DecimalFormat::getPadCharacterString() const {
+    if (fields->properties->padString.isBogus()) {
+        // Readonly-alias the static string kFallbackPaddingString
+        return {TRUE, kFallbackPaddingString, -1};
+    } else {
+        return fields->properties->padString;
     }
 }
 
-void
-DecimalFormat::setCurrencyPluralInfo(const CurrencyPluralInfo& info)
-{
-    adoptCurrencyPluralInfo(info.clone());
+void DecimalFormat::setPadCharacter(const UnicodeString& padChar) {
+    if (padChar == fields->properties->padString) { return; }
+    if (padChar.length() > 0) {
+        fields->properties->padString = UnicodeString(padChar.char32At(0));
+    } else {
+        fields->properties->padString.setToBogus();
+    }
+    touchNoError();
 }
 
-
-//------------------------------------------------------------------------------
-// Gets the positive prefix of the number pattern.
-
-UnicodeString&
-DecimalFormat::getPositivePrefix(UnicodeString& result) const
-{
-    return fImpl->getPositivePrefix(result);
+EPadPosition DecimalFormat::getPadPosition(void) const {
+    if (fields->properties->padPosition.isNull()) {
+        return EPadPosition::kPadBeforePrefix;
+    } else {
+        // UNumberFormatPadPosition and EPadPosition have the same values.
+        return static_cast<EPadPosition>(fields->properties->padPosition.getNoError());
+    }
 }
 
-//------------------------------------------------------------------------------
-// Sets the positive prefix of the number pattern.
-
-void
-DecimalFormat::setPositivePrefix(const UnicodeString& newValue)
-{
-    fImpl->setPositivePrefix(newValue);
+void DecimalFormat::setPadPosition(EPadPosition padPos) {
+    auto uPadPos = static_cast<UNumberFormatPadPosition>(padPos);
+    if (!fields->properties->padPosition.isNull() && uPadPos == fields->properties->padPosition.getNoError()) {
+        return;
+    }
+    fields->properties->padPosition = uPadPos;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Gets the negative prefix  of the number pattern.
-
-UnicodeString&
-DecimalFormat::getNegativePrefix(UnicodeString& result) const
-{
-    return fImpl->getNegativePrefix(result);
+UBool DecimalFormat::isScientificNotation(void) const {
+    return fields->properties->minimumExponentDigits != -1;
 }
 
-//------------------------------------------------------------------------------
-// Gets the negative prefix  of the number pattern.
-
-void
-DecimalFormat::setNegativePrefix(const UnicodeString& newValue)
-{
-    fImpl->setNegativePrefix(newValue);
+void DecimalFormat::setScientificNotation(UBool useScientific) {
+    int32_t minExp = useScientific ? 1 : -1;
+    if (fields->properties->minimumExponentDigits == minExp) { return; }
+    if (useScientific) {
+        fields->properties->minimumExponentDigits = 1;
+    } else {
+        fields->properties->minimumExponentDigits = -1;
+    }
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Gets the positive suffix of the number pattern.
-
-UnicodeString&
-DecimalFormat::getPositiveSuffix(UnicodeString& result) const
-{
-    return fImpl->getPositiveSuffix(result);
+int8_t DecimalFormat::getMinimumExponentDigits(void) const {
+    return static_cast<int8_t>(fields->properties->minimumExponentDigits);
 }
 
-//------------------------------------------------------------------------------
-// Sets the positive suffix of the number pattern.
-
-void
-DecimalFormat::setPositiveSuffix(const UnicodeString& newValue)
-{
-    fImpl->setPositiveSuffix(newValue);
+void DecimalFormat::setMinimumExponentDigits(int8_t minExpDig) {
+    if (minExpDig == fields->properties->minimumExponentDigits) { return; }
+    fields->properties->minimumExponentDigits = minExpDig;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Gets the negative suffix of the number pattern.
-
-UnicodeString&
-DecimalFormat::getNegativeSuffix(UnicodeString& result) const
-{
-    return fImpl->getNegativeSuffix(result);
+UBool DecimalFormat::isExponentSignAlwaysShown(void) const {
+    return fields->properties->exponentSignAlwaysShown;
 }
 
-//------------------------------------------------------------------------------
-// Sets the negative suffix of the number pattern.
-
-void
-DecimalFormat::setNegativeSuffix(const UnicodeString& newValue)
-{
-    fImpl->setNegativeSuffix(newValue);
+void DecimalFormat::setExponentSignAlwaysShown(UBool expSignAlways) {
+    if (UBOOL_TO_BOOL(expSignAlways) == fields->properties->exponentSignAlwaysShown) { return; }
+    fields->properties->exponentSignAlwaysShown = expSignAlways;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Gets the multiplier of the number pattern.
-//   Multipliers are stored as decimal numbers (DigitLists) because that
-//      is the most convenient for muliplying or dividing the numbers to be formatted.
-//   A NULL multiplier implies one, and the scaling operations are skipped.
-
-int32_t
-DecimalFormat::getMultiplier() const
-{
-    return fImpl->getMultiplier();
+int32_t DecimalFormat::getGroupingSize(void) const {
+    if (fields->properties->groupingSize < 0) {
+        return 0;
+    }
+    return fields->properties->groupingSize;
 }
 
-//------------------------------------------------------------------------------
-// Sets the multiplier of the number pattern.
-void
-DecimalFormat::setMultiplier(int32_t newValue)
-{
-    fImpl->setMultiplier(newValue);
-}
-
-/**
- * Get the rounding increment.
- * @return A positive rounding increment, or 0.0 if rounding
- * is not in effect.
- * @see #setRoundingIncrement
- * @see #getRoundingMode
- * @see #setRoundingMode
- */
-double DecimalFormat::getRoundingIncrement() const {
-    return fImpl->getRoundingIncrement();
-}
-
-/**
- * Set the rounding increment.  This method also controls whether
- * rounding is enabled.
- * @param newValue A positive rounding increment, or 0.0 to disable rounding.
- * Negative increments are equivalent to 0.0.
- * @see #getRoundingIncrement
- * @see #getRoundingMode
- * @see #setRoundingMode
- */
-void DecimalFormat::setRoundingIncrement(double newValue) {
-    fImpl->setRoundingIncrement(newValue);
-}
-
-/**
- * Get the rounding mode.
- * @return A rounding mode
- * @see #setRoundingIncrement
- * @see #getRoundingIncrement
- * @see #setRoundingMode
- */
-DecimalFormat::ERoundingMode DecimalFormat::getRoundingMode() const {
-    return fImpl->getRoundingMode();
-}
-
-/**
- * Set the rounding mode.  This has no effect unless the rounding
- * increment is greater than zero.
- * @param roundingMode A rounding mode
- * @see #setRoundingIncrement
- * @see #getRoundingIncrement
- * @see #getRoundingMode
- */
-void DecimalFormat::setRoundingMode(ERoundingMode roundingMode) {
-    fImpl->setRoundingMode(roundingMode);
-}
-
-/**
- * Get the width to which the output of <code>format()</code> is padded.
- * @return the format width, or zero if no padding is in effect
- * @see #setFormatWidth
- * @see #getPadCharacter
- * @see #setPadCharacter
- * @see #getPadPosition
- * @see #setPadPosition
- */
-int32_t DecimalFormat::getFormatWidth() const {
-    return fImpl->getFormatWidth();
-}
-
-/**
- * Set the width to which the output of <code>format()</code> is padded.
- * This method also controls whether padding is enabled.
- * @param width the width to which to pad the result of
- * <code>format()</code>, or zero to disable padding.  A negative
- * width is equivalent to 0.
- * @see #getFormatWidth
- * @see #getPadCharacter
- * @see #setPadCharacter
- * @see #getPadPosition
- * @see #setPadPosition
- */
-void DecimalFormat::setFormatWidth(int32_t width) {
-    int32_t formatWidth = (width > 0) ? width : 0;
-    fImpl->setFormatWidth(formatWidth);
+void DecimalFormat::setGroupingSize(int32_t newValue) {
+    if (newValue == fields->properties->groupingSize) { return; }
+    fields->properties->groupingSize = newValue;
+    touchNoError();
 }
 
-UnicodeString DecimalFormat::getPadCharacterString() const {
-    return UnicodeString(fImpl->getPadCharacter());
+int32_t DecimalFormat::getSecondaryGroupingSize(void) const {
+    int grouping2 = fields->properties->secondaryGroupingSize;
+    if (grouping2 < 0) {
+        return 0;
+    }
+    return grouping2;
 }
 
-void DecimalFormat::setPadCharacter(const UnicodeString &padChar) {
-    UChar32 pad;
-    if (padChar.length() > 0) {
-        pad = padChar.char32At(0);
-    }
-    else {
-        pad = kDefaultPad;
-    }
-    fImpl->setPadCharacter(pad);
-}
-
-static DecimalFormat::EPadPosition fromPadPosition(DigitAffixesAndPadding::EPadPosition padPos) {
-    switch (padPos) {
-    case DigitAffixesAndPadding::kPadBeforePrefix:
-        return DecimalFormat::kPadBeforePrefix;
-    case DigitAffixesAndPadding::kPadAfterPrefix:
-        return DecimalFormat::kPadAfterPrefix;
-    case DigitAffixesAndPadding::kPadBeforeSuffix:
-        return DecimalFormat::kPadBeforeSuffix;
-    case DigitAffixesAndPadding::kPadAfterSuffix:
-        return DecimalFormat::kPadAfterSuffix;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return DecimalFormat::kPadBeforePrefix;
-}
-
-/**
- * Get the position at which padding will take place.  This is the location
- * at which padding will be inserted if the result of <code>format()</code>
- * is shorter than the format width.
- * @return the pad position, one of <code>kPadBeforePrefix</code>,
- * <code>kPadAfterPrefix</code>, <code>kPadBeforeSuffix</code>, or
- * <code>kPadAfterSuffix</code>.
- * @see #setFormatWidth
- * @see #getFormatWidth
- * @see #setPadCharacter
- * @see #getPadCharacter
- * @see #setPadPosition
- * @see #kPadBeforePrefix
- * @see #kPadAfterPrefix
- * @see #kPadBeforeSuffix
- * @see #kPadAfterSuffix
- */
-DecimalFormat::EPadPosition DecimalFormat::getPadPosition() const {
-    return fromPadPosition(fImpl->getPadPosition());
-}
-
-static DigitAffixesAndPadding::EPadPosition toPadPosition(DecimalFormat::EPadPosition padPos) {
-    switch (padPos) {
-    case DecimalFormat::kPadBeforePrefix:
-        return DigitAffixesAndPadding::kPadBeforePrefix;
-    case DecimalFormat::kPadAfterPrefix:
-        return DigitAffixesAndPadding::kPadAfterPrefix;
-    case DecimalFormat::kPadBeforeSuffix:
-        return DigitAffixesAndPadding::kPadBeforeSuffix;
-    case DecimalFormat::kPadAfterSuffix:
-        return DigitAffixesAndPadding::kPadAfterSuffix;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return DigitAffixesAndPadding::kPadBeforePrefix;
-}
-
-/**
- * <strong><font face=helvetica color=red>NEW</font></strong>
- * Set the position at which padding will take place.  This is the location
- * at which padding will be inserted if the result of <code>format()</code>
- * is shorter than the format width.  This has no effect unless padding is
- * enabled.
- * @param padPos the pad position, one of <code>kPadBeforePrefix</code>,
- * <code>kPadAfterPrefix</code>, <code>kPadBeforeSuffix</code>, or
- * <code>kPadAfterSuffix</code>.
- * @see #setFormatWidth
- * @see #getFormatWidth
- * @see #setPadCharacter
- * @see #getPadCharacter
- * @see #getPadPosition
- * @see #kPadBeforePrefix
- * @see #kPadAfterPrefix
- * @see #kPadBeforeSuffix
- * @see #kPadAfterSuffix
- */
-void DecimalFormat::setPadPosition(EPadPosition padPos) {
-    fImpl->setPadPosition(toPadPosition(padPos));
-}
-
-/**
- * Return whether or not scientific notation is used.
- * @return TRUE if this object formats and parses scientific notation
- * @see #setScientificNotation
- * @see #getMinimumExponentDigits
- * @see #setMinimumExponentDigits
- * @see #isExponentSignAlwaysShown
- * @see #setExponentSignAlwaysShown
- */
-UBool DecimalFormat::isScientificNotation() const {
-    return fImpl->isScientificNotation();
-}
-
-/**
- * Set whether or not scientific notation is used.
- * @param useScientific TRUE if this object formats and parses scientific
- * notation
- * @see #isScientificNotation
- * @see #getMinimumExponentDigits
- * @see #setMinimumExponentDigits
- * @see #isExponentSignAlwaysShown
- * @see #setExponentSignAlwaysShown
- */
-void DecimalFormat::setScientificNotation(UBool useScientific) {
-    fImpl->setScientificNotation(useScientific);
-}
-
-/**
- * Return the minimum exponent digits that will be shown.
- * @return the minimum exponent digits that will be shown
- * @see #setScientificNotation
- * @see #isScientificNotation
- * @see #setMinimumExponentDigits
- * @see #isExponentSignAlwaysShown
- * @see #setExponentSignAlwaysShown
- */
-int8_t DecimalFormat::getMinimumExponentDigits() const {
-    return fImpl->getMinimumExponentDigits();
-}
-
-/**
- * Set the minimum exponent digits that will be shown.  This has no
- * effect unless scientific notation is in use.
- * @param minExpDig a value >= 1 indicating the fewest exponent digits
- * that will be shown.  Values less than 1 will be treated as 1.
- * @see #setScientificNotation
- * @see #isScientificNotation
- * @see #getMinimumExponentDigits
- * @see #isExponentSignAlwaysShown
- * @see #setExponentSignAlwaysShown
- */
-void DecimalFormat::setMinimumExponentDigits(int8_t minExpDig) {
-    int32_t minExponentDigits = (int8_t)((minExpDig > 0) ? minExpDig : 1);
-    fImpl->setMinimumExponentDigits(minExponentDigits);
-}
-
-/**
- * Return whether the exponent sign is always shown.
- * @return TRUE if the exponent is always prefixed with either the
- * localized minus sign or the localized plus sign, false if only negative
- * exponents are prefixed with the localized minus sign.
- * @see #setScientificNotation
- * @see #isScientificNotation
- * @see #setMinimumExponentDigits
- * @see #getMinimumExponentDigits
- * @see #setExponentSignAlwaysShown
- */
-UBool DecimalFormat::isExponentSignAlwaysShown() const {
-    return fImpl->isExponentSignAlwaysShown();
-}
-
-/**
- * Set whether the exponent sign is always shown.  This has no effect
- * unless scientific notation is in use.
- * @param expSignAlways TRUE if the exponent is always prefixed with either
- * the localized minus sign or the localized plus sign, false if only
- * negative exponents are prefixed with the localized minus sign.
- * @see #setScientificNotation
- * @see #isScientificNotation
- * @see #setMinimumExponentDigits
- * @see #getMinimumExponentDigits
- * @see #isExponentSignAlwaysShown
- */
-void DecimalFormat::setExponentSignAlwaysShown(UBool expSignAlways) {
-    fImpl->setExponentSignAlwaysShown(expSignAlways);
+void DecimalFormat::setSecondaryGroupingSize(int32_t newValue) {
+    if (newValue == fields->properties->secondaryGroupingSize) { return; }
+    fields->properties->secondaryGroupingSize = newValue;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Gets the grouping size of the number pattern.  For example, thousand or 10
-// thousand groupings.
-
-int32_t
-DecimalFormat::getGroupingSize() const
-{
-    return fImpl->getGroupingSize();
+int32_t DecimalFormat::getMinimumGroupingDigits() const {
+    return fields->properties->minimumGroupingDigits;
 }
 
-//------------------------------------------------------------------------------
-// Gets the grouping size of the number pattern.
-
-void
-DecimalFormat::setGroupingSize(int32_t newValue)
-{
-    fImpl->setGroupingSize(newValue);
+void DecimalFormat::setMinimumGroupingDigits(int32_t newValue) {
+    if (newValue == fields->properties->minimumGroupingDigits) { return; }
+    fields->properties->minimumGroupingDigits = newValue;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-
-int32_t
-DecimalFormat::getSecondaryGroupingSize() const
-{
-    return fImpl->getSecondaryGroupingSize();
+UBool DecimalFormat::isDecimalSeparatorAlwaysShown(void) const {
+    return fields->properties->decimalSeparatorAlwaysShown;
 }
 
-//------------------------------------------------------------------------------
-
-void
-DecimalFormat::setSecondaryGroupingSize(int32_t newValue)
-{
-    fImpl->setSecondaryGroupingSize(newValue);
+void DecimalFormat::setDecimalSeparatorAlwaysShown(UBool newValue) {
+    if (UBOOL_TO_BOOL(newValue) == fields->properties->decimalSeparatorAlwaysShown) { return; }
+    fields->properties->decimalSeparatorAlwaysShown = newValue;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-
-int32_t
-DecimalFormat::getMinimumGroupingDigits() const
-{
-    return fImpl->getMinimumGroupingDigits();
+UBool DecimalFormat::isDecimalPatternMatchRequired(void) const {
+    return fields->properties->decimalPatternMatchRequired;
 }
 
-//------------------------------------------------------------------------------
-
-void
-DecimalFormat::setMinimumGroupingDigits(int32_t newValue)
-{
-    fImpl->setMinimumGroupingDigits(newValue);
+void DecimalFormat::setDecimalPatternMatchRequired(UBool newValue) {
+    if (UBOOL_TO_BOOL(newValue) == fields->properties->decimalPatternMatchRequired) { return; }
+    fields->properties->decimalPatternMatchRequired = newValue;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Checks if to show the decimal separator.
-
-UBool
-DecimalFormat::isDecimalSeparatorAlwaysShown() const
-{
-    return fImpl->isDecimalSeparatorAlwaysShown();
+UBool DecimalFormat::isParseNoExponent() const {
+    return fields->properties->parseNoExponent;
 }
 
-//------------------------------------------------------------------------------
-// Sets to always show the decimal separator.
-
-void
-DecimalFormat::setDecimalSeparatorAlwaysShown(UBool newValue)
-{
-    fImpl->setDecimalSeparatorAlwaysShown(newValue);
+void DecimalFormat::setParseNoExponent(UBool value) {
+    if (UBOOL_TO_BOOL(value) == fields->properties->parseNoExponent) { return; }
+    fields->properties->parseNoExponent = value;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-// Checks if decimal point pattern match is required
-UBool
-DecimalFormat::isDecimalPatternMatchRequired(void) const
-{
-    return static_cast<UBool>(fBoolFlags.contains(UNUM_PARSE_DECIMAL_MARK_REQUIRED));
+UBool DecimalFormat::isParseCaseSensitive() const {
+    return fields->properties->parseCaseSensitive;
 }
 
-//------------------------------------------------------------------------------
-// Checks if decimal point pattern match is required
-
-void
-DecimalFormat::setDecimalPatternMatchRequired(UBool newValue)
-{
-    fBoolFlags.set(UNUM_PARSE_DECIMAL_MARK_REQUIRED, newValue);
+void DecimalFormat::setParseCaseSensitive(UBool value) {
+    if (UBOOL_TO_BOOL(value) == fields->properties->parseCaseSensitive) { return; }
+    fields->properties->parseCaseSensitive = value;
+    touchNoError();
 }
 
-
-//------------------------------------------------------------------------------
-// Emits the pattern of this DecimalFormat instance.
-
-UnicodeString&
-DecimalFormat::toPattern(UnicodeString& result) const
-{
-    return fImpl->toPattern(result);
+UBool DecimalFormat::isFormatFailIfMoreThanMaxDigits() const {
+    return fields->properties->formatFailIfMoreThanMaxDigits;
 }
 
-//------------------------------------------------------------------------------
-// Emits the localized pattern this DecimalFormat instance.
-
-UnicodeString&
-DecimalFormat::toLocalizedPattern(UnicodeString& result) const
-{
-    // toLocalizedPattern is deprecated, so we just make it the same as
-    // toPattern.
-    return fImpl->toPattern(result);
+void DecimalFormat::setFormatFailIfMoreThanMaxDigits(UBool value) {
+    if (UBOOL_TO_BOOL(value) == fields->properties->formatFailIfMoreThanMaxDigits) { return; }
+    fields->properties->formatFailIfMoreThanMaxDigits = value;
+    touchNoError();
 }
 
-//------------------------------------------------------------------------------
-
-void
-DecimalFormat::applyPattern(const UnicodeString& pattern, UErrorCode& status)
-{
-    if (pattern.indexOf(kCurrencySign) != -1) {
-        handleCurrencySignInPattern(status);
+UnicodeString& DecimalFormat::toPattern(UnicodeString& result) const {
+    // Pull some properties from exportedProperties and others from properties
+    // to keep affix patterns intact.  In particular, pull rounding properties
+    // so that CurrencyUsage is reflected properly.
+    // TODO: Consider putting this logic in number_patternstring.cpp instead.
+    ErrorCode localStatus;
+    DecimalFormatProperties tprops(*fields->properties);
+    bool useCurrency = ((!tprops.currency.isNull()) || !tprops.currencyPluralInfo.fPtr.isNull() ||
+                        !tprops.currencyUsage.isNull() || AffixUtils::hasCurrencySymbols(
+            tprops.positivePrefixPattern, localStatus) || AffixUtils::hasCurrencySymbols(
+            tprops.positiveSuffixPattern, localStatus) || AffixUtils::hasCurrencySymbols(
+            tprops.negativePrefixPattern, localStatus) || AffixUtils::hasCurrencySymbols(
+            tprops.negativeSuffixPattern, localStatus));
+    if (useCurrency) {
+        tprops.minimumFractionDigits = fields->exportedProperties->minimumFractionDigits;
+        tprops.maximumFractionDigits = fields->exportedProperties->maximumFractionDigits;
+        tprops.roundingIncrement = fields->exportedProperties->roundingIncrement;
     }
-    fImpl->applyPattern(pattern, status);
+    result = PatternStringUtils::propertiesToPatternString(tprops, localStatus);
+    return result;
 }
 
-//------------------------------------------------------------------------------
+UnicodeString& DecimalFormat::toLocalizedPattern(UnicodeString& result) const {
+    ErrorCode localStatus;
+    result = toPattern(result);
+    result = PatternStringUtils::convertLocalized(result, *fields->symbols, true, localStatus);
+    return result;
+}
 
-void
-DecimalFormat::applyPattern(const UnicodeString& pattern,
-                            UParseError& parseError,
-                            UErrorCode& status)
-{
-    if (pattern.indexOf(kCurrencySign) != -1) {
-        handleCurrencySignInPattern(status);
-    }
-    fImpl->applyPattern(pattern, parseError, status);
+void DecimalFormat::applyPattern(const UnicodeString& pattern, UParseError&, UErrorCode& status) {
+    // TODO: What is parseError for?
+    applyPattern(pattern, status);
 }
-//------------------------------------------------------------------------------
 
-void
-DecimalFormat::applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status)
-{
-    if (pattern.indexOf(kCurrencySign) != -1) {
-        handleCurrencySignInPattern(status);
-    }
-    fImpl->applyLocalizedPattern(pattern, status);
+void DecimalFormat::applyPattern(const UnicodeString& pattern, UErrorCode& status) {
+    setPropertiesFromPattern(pattern, IGNORE_ROUNDING_NEVER, status);
+    touch(status);
 }
 
-//------------------------------------------------------------------------------
+void DecimalFormat::applyLocalizedPattern(const UnicodeString& localizedPattern, UParseError&,
+                                          UErrorCode& status) {
+    // TODO: What is parseError for?
+    applyLocalizedPattern(localizedPattern, status);
+}
 
-void
-DecimalFormat::applyLocalizedPattern(const UnicodeString& pattern,
-                                     UParseError& parseError,
-                                     UErrorCode& status)
-{
-    if (pattern.indexOf(kCurrencySign) != -1) {
-        handleCurrencySignInPattern(status);
+void DecimalFormat::applyLocalizedPattern(const UnicodeString& localizedPattern, UErrorCode& status) {
+    if (U_SUCCESS(status)) {
+        UnicodeString pattern = PatternStringUtils::convertLocalized(
+                localizedPattern, *fields->symbols, false, status);
+        applyPattern(pattern, status);
     }
-    fImpl->applyLocalizedPattern(pattern, parseError, status);
 }
 
-//------------------------------------------------------------------------------
-
-/**
- * Sets the maximum number of digits allowed in the integer portion of a
- * number.
- * @see NumberFormat#setMaximumIntegerDigits
- */
 void DecimalFormat::setMaximumIntegerDigits(int32_t newValue) {
-    newValue = _min(newValue, gDefaultMaxIntegerDigits);
-    NumberFormat::setMaximumIntegerDigits(newValue);
-    fImpl->updatePrecision();
+    if (newValue == fields->properties->maximumIntegerDigits) { return; }
+    // For backwards compatibility, conflicting min/max need to keep the most recent setting.
+    int32_t min = fields->properties->minimumIntegerDigits;
+    if (min >= 0 && min > newValue) {
+        fields->properties->minimumIntegerDigits = newValue;
+    }
+    fields->properties->maximumIntegerDigits = newValue;
+    touchNoError();
 }
 
-/**
- * Sets the minimum number of digits allowed in the integer portion of a
- * number. This override limits the integer digit count to 309.
- * @see NumberFormat#setMinimumIntegerDigits
- */
 void DecimalFormat::setMinimumIntegerDigits(int32_t newValue) {
-    newValue = _min(newValue, kDoubleIntegerDigits);
-    NumberFormat::setMinimumIntegerDigits(newValue);
-    fImpl->updatePrecision();
+    if (newValue == fields->properties->minimumIntegerDigits) { return; }
+    // For backwards compatibility, conflicting min/max need to keep the most recent setting.
+    int32_t max = fields->properties->maximumIntegerDigits;
+    if (max >= 0 && max < newValue) {
+        fields->properties->maximumIntegerDigits = newValue;
+    }
+    fields->properties->minimumIntegerDigits = newValue;
+    touchNoError();
 }
 
-/**
- * Sets the maximum number of digits allowed in the fraction portion of a
- * number. This override limits the fraction digit count to 340.
- * @see NumberFormat#setMaximumFractionDigits
- */
 void DecimalFormat::setMaximumFractionDigits(int32_t newValue) {
-    newValue = _min(newValue, kDoubleFractionDigits);
-    NumberFormat::setMaximumFractionDigits(newValue);
-    fImpl->updatePrecision();
+    if (newValue == fields->properties->maximumFractionDigits) { return; }
+    // For backwards compatibility, conflicting min/max need to keep the most recent setting.
+    int32_t min = fields->properties->minimumFractionDigits;
+    if (min >= 0 && min > newValue) {
+        fields->properties->minimumFractionDigits = newValue;
+    }
+    fields->properties->maximumFractionDigits = newValue;
+    touchNoError();
 }
 
-/**
- * Sets the minimum number of digits allowed in the fraction portion of a
- * number. This override limits the fraction digit count to 340.
- * @see NumberFormat#setMinimumFractionDigits
- */
 void DecimalFormat::setMinimumFractionDigits(int32_t newValue) {
-    newValue = _min(newValue, kDoubleFractionDigits);
-    NumberFormat::setMinimumFractionDigits(newValue);
-    fImpl->updatePrecision();
+    if (newValue == fields->properties->minimumFractionDigits) { return; }
+    // For backwards compatibility, conflicting min/max need to keep the most recent setting.
+    int32_t max = fields->properties->maximumFractionDigits;
+    if (max >= 0 && max < newValue) {
+        fields->properties->maximumFractionDigits = newValue;
+    }
+    fields->properties->minimumFractionDigits = newValue;
+    touchNoError();
 }
 
 int32_t DecimalFormat::getMinimumSignificantDigits() const {
-    return fImpl->getMinimumSignificantDigits();
+    return fields->exportedProperties->minimumSignificantDigits;
 }
 
 int32_t DecimalFormat::getMaximumSignificantDigits() const {
-    return fImpl->getMaximumSignificantDigits();
+    return fields->exportedProperties->maximumSignificantDigits;
 }
 
-void DecimalFormat::setMinimumSignificantDigits(int32_t min) {
-    if (min < 1) {
-        min = 1;
+void DecimalFormat::setMinimumSignificantDigits(int32_t value) {
+    if (value == fields->properties->minimumSignificantDigits) { return; }
+    int32_t max = fields->properties->maximumSignificantDigits;
+    if (max >= 0 && max < value) {
+        fields->properties->maximumSignificantDigits = value;
     }
-    // pin max sig dig to >= min
-    int32_t max = _max(fImpl->fMaxSigDigits, min);
-    fImpl->setMinMaxSignificantDigits(min, max);
+    fields->properties->minimumSignificantDigits = value;
+    touchNoError();
 }
 
-void DecimalFormat::setMaximumSignificantDigits(int32_t max) {
-    if (max < 1) {
-        max = 1;
+void DecimalFormat::setMaximumSignificantDigits(int32_t value) {
+    if (value == fields->properties->maximumSignificantDigits) { return; }
+    int32_t min = fields->properties->minimumSignificantDigits;
+    if (min >= 0 && min > value) {
+        fields->properties->minimumSignificantDigits = value;
     }
-    // pin min sig dig to 1..max
-    U_ASSERT(fImpl->fMinSigDigits >= 1);
-    int32_t min = _min(fImpl->fMinSigDigits, max);
-    fImpl->setMinMaxSignificantDigits(min, max);
+    fields->properties->maximumSignificantDigits = value;
+    touchNoError();
 }
 
 UBool DecimalFormat::areSignificantDigitsUsed() const {
-    return fImpl->areSignificantDigitsUsed();
+    return fields->properties->minimumSignificantDigits != -1 || fields->properties->maximumSignificantDigits != -1;
 }
 
 void DecimalFormat::setSignificantDigitsUsed(UBool useSignificantDigits) {
-    fImpl->setSignificantDigitsUsed(useSignificantDigits);
-}
-
-void DecimalFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
-    // set the currency before compute affixes to get the right currency names
-    NumberFormat::setCurrency(theCurrency, ec);
-    fImpl->updateCurrency(ec);
-}
-
-void DecimalFormat::setCurrencyUsage(UCurrencyUsage newContext, UErrorCode* ec){
-    fImpl->setCurrencyUsage(newContext, *ec);
-}
-
-UCurrencyUsage DecimalFormat::getCurrencyUsage() const {
-    return fImpl->getCurrencyUsage();
-}
-
-// Deprecated variant with no UErrorCode parameter
-void DecimalFormat::setCurrency(const UChar* theCurrency) {
-    UErrorCode ec = U_ZERO_ERROR;
-    setCurrency(theCurrency, ec);
+    // These are the default values from the old implementation.
+    int32_t minSig = useSignificantDigits ? 1 : -1;
+    int32_t maxSig = useSignificantDigits ? 6 : -1;
+    if (fields->properties->minimumSignificantDigits == minSig &&
+        fields->properties->maximumSignificantDigits == maxSig) {
+        return;
+    }
+    fields->properties->minimumSignificantDigits = minSig;
+    fields->properties->maximumSignificantDigits = maxSig;
+    touchNoError();
 }
 
-void DecimalFormat::getEffectiveCurrency(UChar* result, UErrorCode& ec) const {
-    if (fImpl->fSymbols == NULL) {
-        ec = U_MEMORY_ALLOCATION_ERROR;
+void DecimalFormat::setCurrency(const char16_t* theCurrency, UErrorCode& ec) {
+    CurrencyUnit currencyUnit(theCurrency, ec);
+    if (U_FAILURE(ec)) { return; }
+    if (!fields->properties->currency.isNull() && fields->properties->currency.getNoError() == currencyUnit) {
         return;
     }
-    ec = U_ZERO_ERROR;
-    const UChar* c = getCurrency();
-    if (*c == 0) {
-        const UnicodeString &intl =
-            fImpl->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol);
-        c = intl.getBuffer(); // ok for intl to go out of scope
-    }
-    u_strncpy(result, c, 3);
-    result[3] = 0;
+    NumberFormat::setCurrency(theCurrency, ec); // to set field for compatibility
+    fields->properties->currency = currencyUnit;
+    // TODO: Set values in fields->symbols, too?
+    touchNoError();
 }
 
-Hashtable*
-DecimalFormat::initHashForAffixPattern(UErrorCode& status) {
-    if ( U_FAILURE(status) ) {
-        return NULL;
-    }
-    Hashtable* hTable;
-    if ( (hTable = new Hashtable(TRUE, status)) == NULL ) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return NULL;
-    }
-    if ( U_FAILURE(status) ) {
-        delete hTable;
-        return NULL;
-    }
-    hTable->setValueComparator(decimfmtAffixPatternValueComparator);
-    return hTable;
+void DecimalFormat::setCurrency(const char16_t* theCurrency) {
+    ErrorCode localStatus;
+    setCurrency(theCurrency, localStatus);
 }
 
-void
-DecimalFormat::deleteHashForAffixPattern()
-{
-    if ( fAffixPatternsForCurrency == NULL ) {
+void DecimalFormat::setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec) {
+    if (U_FAILURE(*ec)) {
         return;
     }
-    int32_t pos = UHASH_FIRST;
-    const UHashElement* element = NULL;
-    while ( (element = fAffixPatternsForCurrency->nextElement(pos)) != NULL ) {
-        const UHashTok valueTok = element->value;
-        const AffixPatternsForCurrency* value = (AffixPatternsForCurrency*)valueTok.pointer;
-        delete value;
+    if (!fields->properties->currencyUsage.isNull() && newUsage == fields->properties->currencyUsage.getNoError()) {
+        return;
     }
-    delete fAffixPatternsForCurrency;
-    fAffixPatternsForCurrency = NULL;
+    fields->properties->currencyUsage = newUsage;
+    touch(*ec);
 }
 
-
-void
-DecimalFormat::copyHashForAffixPattern(const Hashtable* source,
-                                       Hashtable* target,
-                                       UErrorCode& status) {
-    if ( U_FAILURE(status) ) {
-        return;
-    }
-    int32_t pos = UHASH_FIRST;
-    const UHashElement* element = NULL;
-    if ( source ) {
-        while ( (element = source->nextElement(pos)) != NULL ) {
-            const UHashTok keyTok = element->key;
-            const UnicodeString* key = (UnicodeString*)keyTok.pointer;
-            const UHashTok valueTok = element->value;
-            const AffixPatternsForCurrency* value = (AffixPatternsForCurrency*)valueTok.pointer;
-            AffixPatternsForCurrency* copy = new AffixPatternsForCurrency(
-                value->negPrefixPatternForCurrency,
-                value->negSuffixPatternForCurrency,
-                value->posPrefixPatternForCurrency,
-                value->posSuffixPatternForCurrency,
-                value->patternType);
-            target->put(UnicodeString(*key), copy, status);
-            if ( U_FAILURE(status) ) {
-                return;
-            }
-        }
+UCurrencyUsage DecimalFormat::getCurrencyUsage() const {
+    // CurrencyUsage is not exported, so we have to get it from the input property bag.
+    // TODO: Should we export CurrencyUsage instead?
+    if (fields->properties->currencyUsage.isNull()) {
+        return UCURR_USAGE_STANDARD;
     }
+    return fields->properties->currencyUsage.getNoError();
 }
 
 void
-DecimalFormat::setGroupingUsed(UBool newValue) {
-  NumberFormat::setGroupingUsed(newValue);
-  fImpl->updateGrouping();
+DecimalFormat::formatToDecimalQuantity(double number, DecimalQuantity& output, UErrorCode& status) const {
+    fields->formatter->formatDouble(number, status).getDecimalQuantity(output, status);
 }
 
-void
-DecimalFormat::setParseIntegerOnly(UBool newValue) {
-  NumberFormat::setParseIntegerOnly(newValue);
+void DecimalFormat::formatToDecimalQuantity(const Formattable& number, DecimalQuantity& output,
+                                            UErrorCode& status) const {
+    UFormattedNumberData obj;
+    number.populateDecimalQuantity(obj.quantity, status);
+    fields->formatter->formatImpl(&obj, status);
+    output = std::move(obj.quantity);
 }
 
-void
-DecimalFormat::setContext(UDisplayContext value, UErrorCode& status) {
-  NumberFormat::setContext(value, status);
+const number::LocalizedNumberFormatter& DecimalFormat::toNumberFormatter() const {
+    return *fields->formatter;
 }
 
-DecimalFormat& DecimalFormat::setAttribute( UNumberFormatAttribute attr,
-                                            int32_t newValue,
-                                            UErrorCode &status) {
-  if(U_FAILURE(status)) return *this;
-
-  switch(attr) {
-  case UNUM_LENIENT_PARSE:
-    setLenient(newValue!=0);
-    break;
-
-    case UNUM_PARSE_INT_ONLY:
-      setParseIntegerOnly(newValue!=0);
-      break;
-
-    case UNUM_GROUPING_USED:
-      setGroupingUsed(newValue!=0);
-      break;
-
-    case UNUM_DECIMAL_ALWAYS_SHOWN:
-      setDecimalSeparatorAlwaysShown(newValue!=0);
-        break;
-
-    case UNUM_MAX_INTEGER_DIGITS:
-      setMaximumIntegerDigits(newValue);
-        break;
-
-    case UNUM_MIN_INTEGER_DIGITS:
-      setMinimumIntegerDigits(newValue);
-        break;
-
-    case UNUM_INTEGER_DIGITS:
-      setMinimumIntegerDigits(newValue);
-      setMaximumIntegerDigits(newValue);
-        break;
-
-    case UNUM_MAX_FRACTION_DIGITS:
-      setMaximumFractionDigits(newValue);
-        break;
-
-    case UNUM_MIN_FRACTION_DIGITS:
-      setMinimumFractionDigits(newValue);
-        break;
-
-    case UNUM_FRACTION_DIGITS:
-      setMinimumFractionDigits(newValue);
-      setMaximumFractionDigits(newValue);
-      break;
-
-    case UNUM_SIGNIFICANT_DIGITS_USED:
-      setSignificantDigitsUsed(newValue!=0);
-        break;
-
-    case UNUM_MAX_SIGNIFICANT_DIGITS:
-      setMaximumSignificantDigits(newValue);
-        break;
-
-    case UNUM_MIN_SIGNIFICANT_DIGITS:
-      setMinimumSignificantDigits(newValue);
-        break;
-
-    case UNUM_MULTIPLIER:
-      setMultiplier(newValue);
-       break;
-
-    case UNUM_GROUPING_SIZE:
-      setGroupingSize(newValue);
-        break;
-
-    case UNUM_ROUNDING_MODE:
-      setRoundingMode((DecimalFormat::ERoundingMode)newValue);
-        break;
-
-    case UNUM_FORMAT_WIDTH:
-      setFormatWidth(newValue);
-        break;
-
-    case UNUM_PADDING_POSITION:
-        /** The position at which padding will take place. */
-      setPadPosition((DecimalFormat::EPadPosition)newValue);
-        break;
-
-    case UNUM_SECONDARY_GROUPING_SIZE:
-      setSecondaryGroupingSize(newValue);
-        break;
-
-#if UCONFIG_HAVE_PARSEALLINPUT
-    case UNUM_PARSE_ALL_INPUT:
-      setParseAllInput((UNumberFormatAttributeValue)newValue);
-        break;
-#endif
+/** Rebuilds the formatter object from the property bag. */
+void DecimalFormat::touch(UErrorCode& status) {
+    if (fields->exportedProperties == nullptr) {
+        // fields->exportedProperties is null only when the formatter is not ready yet.
+        // The only time when this happens is during legacy deserialization.
+        return;
+    }
 
-    /* These are stored in fBoolFlags */
-    case UNUM_PARSE_NO_EXPONENT:
-    case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS:
-    case UNUM_PARSE_DECIMAL_MARK_REQUIRED:
-      if(!fBoolFlags.isValidValue(newValue)) {
-          status = U_ILLEGAL_ARGUMENT_ERROR;
-      } else {
-          if (attr == UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS) {
-              fImpl->setFailIfMoreThanMaxDigits((UBool) newValue);
-          }
-          fBoolFlags.set(attr, newValue);
-      }
-      break;
+    // In C++, fields->symbols is the source of truth for the locale.
+    Locale locale = fields->symbols->getLocale();
 
-    case UNUM_SCALE:
-        fImpl->setScale(newValue);
-        break;
+    // Note: The formatter is relatively cheap to create, and we need it to populate fields->exportedProperties,
+    // so automatically compute it here. The parser is a bit more expensive and is not needed until the
+    // parse method is called, so defer that until needed.
+    // TODO: Only update the pieces that changed instead of re-computing the whole formatter?
+    fields->formatter.adoptInstead(
+            new LocalizedNumberFormatter(
+                    NumberPropertyMapper::create(
+                            *fields->properties, *fields->symbols, fields->warehouse, *fields->exportedProperties, status).locale(
+                            locale)));
 
-    case UNUM_CURRENCY_USAGE:
-        setCurrencyUsage((UCurrencyUsage)newValue, &status);
-        break;
+    // Do this after fields->exportedProperties are set up
+    setupFastFormat();
 
-    case UNUM_MINIMUM_GROUPING_DIGITS:
-        setMinimumGroupingDigits(newValue);
-        break;
+    // Delete the parsers if they were made previously
+    delete fields->atomicParser.exchange(nullptr);
+    delete fields->atomicCurrencyParser.exchange(nullptr);
 
-    default:
-      status = U_UNSUPPORTED_ERROR;
-      break;
-  }
-  return *this;
+    // In order for the getters to work, we need to populate some fields in NumberFormat.
+    NumberFormat::setCurrency(fields->exportedProperties->currency.get(status).getISOCurrency(), status);
+    NumberFormat::setMaximumIntegerDigits(fields->exportedProperties->maximumIntegerDigits);
+    NumberFormat::setMinimumIntegerDigits(fields->exportedProperties->minimumIntegerDigits);
+    NumberFormat::setMaximumFractionDigits(fields->exportedProperties->maximumFractionDigits);
+    NumberFormat::setMinimumFractionDigits(fields->exportedProperties->minimumFractionDigits);
+    // fImpl->properties, not fields->exportedProperties, since this information comes from the pattern:
+    NumberFormat::setGroupingUsed(fields->properties->groupingUsed);
 }
 
-int32_t DecimalFormat::getAttribute( UNumberFormatAttribute attr,
-                                     UErrorCode &status ) const {
-  if(U_FAILURE(status)) return -1;
-  switch(attr) {
-    case UNUM_LENIENT_PARSE:
-        return isLenient();
-
-    case UNUM_PARSE_INT_ONLY:
-        return isParseIntegerOnly();
-
-    case UNUM_GROUPING_USED:
-        return isGroupingUsed();
-
-    case UNUM_DECIMAL_ALWAYS_SHOWN:
-        return isDecimalSeparatorAlwaysShown();
+void DecimalFormat::touchNoError() {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    touch(localStatus);
+}
 
-    case UNUM_MAX_INTEGER_DIGITS:
-        return getMaximumIntegerDigits();
+void DecimalFormat::setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding,
+                                             UErrorCode& status) {
+    if (U_SUCCESS(status)) {
+        // Cast workaround to get around putting the enum in the public header file
+        auto actualIgnoreRounding = static_cast<IgnoreRounding>(ignoreRounding);
+        PatternParser::parseToExistingProperties(pattern, *fields->properties,  actualIgnoreRounding, status);
+    }
+}
 
-    case UNUM_MIN_INTEGER_DIGITS:
-        return getMinimumIntegerDigits();
+const numparse::impl::NumberParserImpl* DecimalFormat::getParser(UErrorCode& status) const {
+    if (U_FAILURE(status)) { return nullptr; }
 
-    case UNUM_INTEGER_DIGITS:
-        // TBD: what should this return?
-        return getMinimumIntegerDigits();
+    // First try to get the pre-computed parser
+    auto* ptr = fields->atomicParser.load();
+    if (ptr != nullptr) {
+        return ptr;
+    }
 
-    case UNUM_MAX_FRACTION_DIGITS:
-        return getMaximumFractionDigits();
+    // Try computing the parser on our own
+    auto* temp = NumberParserImpl::createParserFromProperties(*fields->properties, *fields->symbols, false, status);
+    if (temp == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        // although we may still dereference, call sites should be guarded
+    }
 
-    case UNUM_MIN_FRACTION_DIGITS:
-        return getMinimumFractionDigits();
+    // Note: ptr starts as nullptr; during compare_exchange, it is set to what is actually stored in the
+    // atomic if another thread beat us to computing the parser object.
+    auto* nonConstThis = const_cast<DecimalFormat*>(this);
+    if (!nonConstThis->fields->atomicParser.compare_exchange_strong(ptr, temp)) {
+        // Another thread beat us to computing the parser
+        delete temp;
+        return ptr;
+    } else {
+        // Our copy of the parser got stored in the atomic
+        return temp;
+    }
+}
 
-    case UNUM_FRACTION_DIGITS:
-        // TBD: what should this return?
-        return getMinimumFractionDigits();
+const numparse::impl::NumberParserImpl* DecimalFormat::getCurrencyParser(UErrorCode& status) const {
+    if (U_FAILURE(status)) { return nullptr; }
 
-    case UNUM_SIGNIFICANT_DIGITS_USED:
-        return areSignificantDigitsUsed();
+    // First try to get the pre-computed parser
+    auto* ptr = fields->atomicCurrencyParser.load();
+    if (ptr != nullptr) {
+        return ptr;
+    }
 
-    case UNUM_MAX_SIGNIFICANT_DIGITS:
-        return getMaximumSignificantDigits();
+    // Try computing the parser on our own
+    auto* temp = NumberParserImpl::createParserFromProperties(*fields->properties, *fields->symbols, true, status);
+    if (temp == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        // although we may still dereference, call sites should be guarded
+    }
 
-    case UNUM_MIN_SIGNIFICANT_DIGITS:
-        return getMinimumSignificantDigits();
+    // Note: ptr starts as nullptr; during compare_exchange, it is set to what is actually stored in the
+    // atomic if another thread beat us to computing the parser object.
+    auto* nonConstThis = const_cast<DecimalFormat*>(this);
+    if (!nonConstThis->fields->atomicCurrencyParser.compare_exchange_strong(ptr, temp)) {
+        // Another thread beat us to computing the parser
+        delete temp;
+        return ptr;
+    } else {
+        // Our copy of the parser got stored in the atomic
+        return temp;
+    }
+}
 
-    case UNUM_MULTIPLIER:
-        return getMultiplier();
+void
+DecimalFormat::fieldPositionHelper(const number::FormattedNumber& formatted, FieldPosition& fieldPosition,
+                                   int32_t offset, UErrorCode& status) {
+    // always return first occurrence:
+    fieldPosition.setBeginIndex(0);
+    fieldPosition.setEndIndex(0);
+    bool found = formatted.nextFieldPosition(fieldPosition, status);
+    if (found && offset != 0) {
+        FieldPositionOnlyHandler fpoh(fieldPosition);
+        fpoh.shiftLast(offset);
+    }
+}
 
-    case UNUM_GROUPING_SIZE:
-        return getGroupingSize();
+void
+DecimalFormat::fieldPositionIteratorHelper(const number::FormattedNumber& formatted, FieldPositionIterator* fpi,
+                                           int32_t offset, UErrorCode& status) {
+    if (fpi != nullptr) {
+        FieldPositionIteratorHandler fpih(fpi, status);
+        fpih.setShift(offset);
+        formatted.getAllFieldPositionsImpl(fpih, status);
+    }
+}
 
-    case UNUM_ROUNDING_MODE:
-        return getRoundingMode();
+// To debug fast-format, change void(x) to printf(x)
+#define trace(x) void(x)
 
-    case UNUM_FORMAT_WIDTH:
-        return getFormatWidth();
+void DecimalFormat::setupFastFormat() {
+    // Check the majority of properties:
+    if (!fields->properties->equalsDefaultExceptFastFormat()) {
+        trace("no fast format: equality\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    case UNUM_PADDING_POSITION:
-        return getPadPosition();
+    // Now check the remaining properties.
+    // Nontrivial affixes:
+    UBool trivialPP = fields->properties->positivePrefixPattern.isEmpty();
+    UBool trivialPS = fields->properties->positiveSuffixPattern.isEmpty();
+    UBool trivialNP = fields->properties->negativePrefixPattern.isBogus() || (
+            fields->properties->negativePrefixPattern.length() == 1 &&
+            fields->properties->negativePrefixPattern.charAt(0) == u'-');
+    UBool trivialNS = fields->properties->negativeSuffixPattern.isEmpty();
+    if (!trivialPP || !trivialPS || !trivialNP || !trivialNS) {
+        trace("no fast format: affixes\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    case UNUM_SECONDARY_GROUPING_SIZE:
-        return getSecondaryGroupingSize();
+    // Grouping (secondary grouping is forbidden in equalsDefaultExceptFastFormat):
+    bool groupingUsed = fields->properties->groupingUsed;
+    int32_t groupingSize = fields->properties->groupingSize;
+    bool unusualGroupingSize = groupingSize > 0 && groupingSize != 3;
+    const UnicodeString& groupingString = fields->symbols->getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
+    if (groupingUsed && (unusualGroupingSize || groupingString.length() != 1)) {
+        trace("no fast format: grouping\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    /* These are stored in fBoolFlags */
-    case UNUM_PARSE_NO_EXPONENT:
-    case UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS:
-    case UNUM_PARSE_DECIMAL_MARK_REQUIRED:
-      return fBoolFlags.get(attr);
+    // Integer length:
+    int32_t minInt = fields->exportedProperties->minimumIntegerDigits;
+    int32_t maxInt = fields->exportedProperties->maximumIntegerDigits;
+    // Fastpath supports up to only 10 digits (length of INT32_MIN)
+    if (minInt > 10) {
+        trace("no fast format: integer\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    case UNUM_SCALE:
-        return fImpl->fScale;
+    // Fraction length (no fraction part allowed in fast path):
+    int32_t minFrac = fields->exportedProperties->minimumFractionDigits;
+    if (minFrac > 0) {
+        trace("no fast format: fraction\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    case UNUM_CURRENCY_USAGE:
-        return fImpl->getCurrencyUsage();
+    // Other symbols:
+    const UnicodeString& minusSignString = fields->symbols->getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
+    UChar32 codePointZero = fields->symbols->getCodePointZero();
+    if (minusSignString.length() != 1 || U16_LENGTH(codePointZero) != 1) {
+        trace("no fast format: symbols\n");
+        fields->canUseFastFormat = false;
+        return;
+    }
 
-    case UNUM_MINIMUM_GROUPING_DIGITS:
-        return getMinimumGroupingDigits();
+    // Good to go!
+    trace("can use fast format!\n");
+    fields->canUseFastFormat = true;
+    fields->fastData.cpZero = static_cast<char16_t>(codePointZero);
+    fields->fastData.cpGroupingSeparator = groupingUsed && groupingSize == 3 ? groupingString.charAt(0) : 0;
+    fields->fastData.cpMinusSign = minusSignString.charAt(0);
+    fields->fastData.minInt = (minInt < 0 || minInt > 127) ? 0 : static_cast<int8_t>(minInt);
+    fields->fastData.maxInt = (maxInt < 0 || maxInt > 127) ? 127 : static_cast<int8_t>(maxInt);
+}
 
-    default:
-        status = U_UNSUPPORTED_ERROR;
-        break;
-  }
+bool DecimalFormat::fastFormatDouble(double input, UnicodeString& output) const {
+    if (!fields->canUseFastFormat) {
+        return false;
+    }
+    if (std::isnan(input)
+            || std::trunc(input) != input
+            || input <= INT32_MIN
+            || input > INT32_MAX) {
+        return false;
+    }
+    doFastFormatInt32(static_cast<int32_t>(input), std::signbit(input), output);
+    return true;
+}
 
-  return -1; /* undefined */
+bool DecimalFormat::fastFormatInt64(int64_t input, UnicodeString& output) const {
+    if (!fields->canUseFastFormat) {
+        return false;
+    }
+    if (input <= INT32_MIN || input > INT32_MAX) {
+        return false;
+    }
+    doFastFormatInt32(static_cast<int32_t>(input), input < 0, output);
+    return true;
 }
 
-#if UCONFIG_HAVE_PARSEALLINPUT
-void DecimalFormat::setParseAllInput(UNumberFormatAttributeValue value) {
-  fParseAllInput = value;
+void DecimalFormat::doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const {
+    U_ASSERT(fields->canUseFastFormat);
+    if (isNegative) {
+        output.append(fields->fastData.cpMinusSign);
+        U_ASSERT(input != INT32_MIN);  // handled by callers
+        input = -input;
+    }
+    // Cap at int32_t to make the buffer small and operations fast.
+    // Longest string: "2,147,483,648" (13 chars in length)
+    static constexpr int32_t localCapacity = 13;
+    char16_t localBuffer[localCapacity];
+    char16_t* ptr = localBuffer + localCapacity;
+    int8_t group = 0;
+    for (int8_t i = 0; i < fields->fastData.maxInt && (input != 0 || i < fields->fastData.minInt); i++) {
+        if (group++ == 3 && fields->fastData.cpGroupingSeparator != 0) {
+            *(--ptr) = fields->fastData.cpGroupingSeparator;
+            group = 1;
+        }
+        std::div_t res = std::div(input, 10);
+        *(--ptr) = static_cast<char16_t>(fields->fastData.cpZero + res.rem);
+        input = res.quot;
+    }
+    int32_t len = localCapacity - static_cast<int32_t>(ptr - localBuffer);
+    output.append(ptr, len);
 }
-#endif
 
-U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
-
-//eof
diff --git a/deps/icu-small/source/i18n/decimfmtimpl.cpp b/deps/icu-small/source/i18n/decimfmtimpl.cpp
deleted file mode 100644
index ef44eab0101453..00000000000000
--- a/deps/icu-small/source/i18n/decimfmtimpl.cpp
+++ /dev/null
@@ -1,1596 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: decimfmtimpl.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include <math.h>
-#include "unicode/numfmt.h"
-#include "unicode/plurrule.h"
-#include "unicode/ustring.h"
-#include "decimalformatpattern.h"
-#include "decimalformatpatternimpl.h"
-#include "decimfmtimpl.h"
-#include "fphdlimp.h"
-#include "plurrule_impl.h"
-#include "valueformatter.h"
-#include "visibledigits.h"
-
-U_NAMESPACE_BEGIN
-
-static const int32_t kMaxScientificIntegerDigits = 8;
-
-static const int32_t kFormattingPosPrefix = (1 << 0);
-static const int32_t kFormattingNegPrefix = (1 << 1);
-static const int32_t kFormattingPosSuffix = (1 << 2);
-static const int32_t kFormattingNegSuffix = (1 << 3);
-static const int32_t kFormattingSymbols = (1 << 4);
-static const int32_t kFormattingCurrency = (1 << 5);
-static const int32_t kFormattingUsesCurrency = (1 << 6);
-static const int32_t kFormattingPluralRules = (1 << 7);
-static const int32_t kFormattingAffixParser = (1 << 8);
-static const int32_t kFormattingCurrencyAffixInfo = (1 << 9);
-static const int32_t kFormattingAll = (1 << 10) - 1;
-static const int32_t kFormattingAffixes =
-        kFormattingPosPrefix | kFormattingPosSuffix |
-        kFormattingNegPrefix | kFormattingNegSuffix;
-static const int32_t kFormattingAffixParserWithCurrency =
-        kFormattingAffixParser | kFormattingCurrencyAffixInfo;
-
-DecimalFormatImpl::DecimalFormatImpl(
-        NumberFormat *super,
-        const Locale &locale,
-        const UnicodeString &pattern,
-        UErrorCode &status)
-        : fSuper(super),
-          fScale(0),
-          fRoundingMode(DecimalFormat::kRoundHalfEven),
-          fSymbols(NULL),
-          fCurrencyUsage(UCURR_USAGE_STANDARD),
-          fRules(NULL),
-          fMonetary(FALSE) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fSymbols = new DecimalFormatSymbols(
-            locale, status);
-    if (fSymbols == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return;
-    }
-    UParseError parseError;
-    applyPattern(pattern, FALSE, parseError, status);
-    updateAll(status);
-}
-
-DecimalFormatImpl::DecimalFormatImpl(
-        NumberFormat *super,
-        const UnicodeString &pattern,
-        DecimalFormatSymbols *symbolsToAdopt,
-        UParseError &parseError,
-        UErrorCode &status)
-        : fSuper(super),
-          fScale(0),
-          fRoundingMode(DecimalFormat::kRoundHalfEven),
-          fSymbols(symbolsToAdopt),
-          fCurrencyUsage(UCURR_USAGE_STANDARD),
-          fRules(NULL),
-          fMonetary(FALSE) {
-    applyPattern(pattern, FALSE, parseError, status);
-    updateAll(status);
-}
-
-DecimalFormatImpl::DecimalFormatImpl(
-    NumberFormat *super, const DecimalFormatImpl &other, UErrorCode &status) :
-          fSuper(super),
-          fMultiplier(other.fMultiplier),
-          fScale(other.fScale),
-          fRoundingMode(other.fRoundingMode),
-          fMinSigDigits(other.fMinSigDigits),
-          fMaxSigDigits(other.fMaxSigDigits),
-          fUseScientific(other.fUseScientific),
-          fUseSigDigits(other.fUseSigDigits),
-          fGrouping(other.fGrouping),
-          fPositivePrefixPattern(other.fPositivePrefixPattern),
-          fNegativePrefixPattern(other.fNegativePrefixPattern),
-          fPositiveSuffixPattern(other.fPositiveSuffixPattern),
-          fNegativeSuffixPattern(other.fNegativeSuffixPattern),
-          fSymbols(other.fSymbols),
-          fCurrencyUsage(other.fCurrencyUsage),
-          fRules(NULL),
-          fMonetary(other.fMonetary),
-          fAffixParser(other.fAffixParser),
-          fCurrencyAffixInfo(other.fCurrencyAffixInfo),
-          fEffPrecision(other.fEffPrecision),
-          fEffGrouping(other.fEffGrouping),
-          fOptions(other.fOptions),
-          fFormatter(other.fFormatter),
-          fAffixes(other.fAffixes) {
-    fSymbols = new DecimalFormatSymbols(*fSymbols);
-    if (fSymbols == NULL && U_SUCCESS(status)) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
-    if (other.fRules != NULL) {
-        fRules = new PluralRules(*other.fRules);
-        if (fRules == NULL && U_SUCCESS(status)) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-        }
-    }
-}
-
-
-DecimalFormatImpl &
-DecimalFormatImpl::assign(const DecimalFormatImpl &other, UErrorCode &status) {
-    if (U_FAILURE(status) || this == &other) {
-        return (*this);
-    }
-    UObject::operator=(other);
-    fMultiplier = other.fMultiplier;
-    fScale = other.fScale;
-    fRoundingMode = other.fRoundingMode;
-    fMinSigDigits = other.fMinSigDigits;
-    fMaxSigDigits = other.fMaxSigDigits;
-    fUseScientific = other.fUseScientific;
-    fUseSigDigits = other.fUseSigDigits;
-    fGrouping = other.fGrouping;
-    fPositivePrefixPattern = other.fPositivePrefixPattern;
-    fNegativePrefixPattern = other.fNegativePrefixPattern;
-    fPositiveSuffixPattern = other.fPositiveSuffixPattern;
-    fNegativeSuffixPattern = other.fNegativeSuffixPattern;
-    fCurrencyUsage = other.fCurrencyUsage;
-    fMonetary = other.fMonetary;
-    fAffixParser = other.fAffixParser;
-    fCurrencyAffixInfo = other.fCurrencyAffixInfo;
-    fEffPrecision = other.fEffPrecision;
-    fEffGrouping = other.fEffGrouping;
-    fOptions = other.fOptions;
-    fFormatter = other.fFormatter;
-    fAffixes = other.fAffixes;
-    *fSymbols = *other.fSymbols;
-    if (fRules != NULL && other.fRules != NULL) {
-        *fRules = *other.fRules;
-    } else {
-        delete fRules;
-        fRules = other.fRules;
-        if (fRules != NULL) {
-            fRules = new PluralRules(*fRules);
-            if (fRules == NULL) {
-                status = U_MEMORY_ALLOCATION_ERROR;
-                return *this;
-            }
-        }
-    }
-    return *this;
-}
-
-UBool
-DecimalFormatImpl::operator==(const DecimalFormatImpl &other) const {
-    if (this == &other) {
-        return TRUE;
-    }
-    return (fMultiplier == other.fMultiplier)
-            && (fScale == other.fScale)
-            && (fRoundingMode == other.fRoundingMode)
-            && (fMinSigDigits == other.fMinSigDigits)
-            && (fMaxSigDigits == other.fMaxSigDigits)
-            && (fUseScientific == other.fUseScientific)
-            && (fUseSigDigits == other.fUseSigDigits)
-            && fGrouping.equals(other.fGrouping)
-            && fPositivePrefixPattern.equals(other.fPositivePrefixPattern)
-            && fNegativePrefixPattern.equals(other.fNegativePrefixPattern)
-            && fPositiveSuffixPattern.equals(other.fPositiveSuffixPattern)
-            && fNegativeSuffixPattern.equals(other.fNegativeSuffixPattern)
-            && fCurrencyUsage == other.fCurrencyUsage
-            && fAffixParser.equals(other.fAffixParser)
-            && fCurrencyAffixInfo.equals(other.fCurrencyAffixInfo)
-            && fEffPrecision.equals(other.fEffPrecision)
-            && fEffGrouping.equals(other.fEffGrouping)
-            && fOptions.equals(other.fOptions)
-            && fFormatter.equals(other.fFormatter)
-            && fAffixes.equals(other.fAffixes)
-            && (*fSymbols == *other.fSymbols)
-            && ((fRules == other.fRules) || (
-                    (fRules != NULL) && (other.fRules != NULL)
-                    && (*fRules == *other.fRules)))
-            && (fMonetary == other.fMonetary);
-}
-
-DecimalFormatImpl::~DecimalFormatImpl() {
-    delete fSymbols;
-    delete fRules;
-}
-
-ValueFormatter &
-DecimalFormatImpl::prepareValueFormatter(ValueFormatter &vf) const {
-    if (fUseScientific) {
-        vf.prepareScientificFormatting(
-                fFormatter, fEffPrecision, fOptions);
-        return vf;
-    }
-    vf.prepareFixedDecimalFormatting(
-            fFormatter, fEffGrouping, fEffPrecision.fMantissa, fOptions.fMantissa);
-    return vf;
-}
-
-int32_t
-DecimalFormatImpl::getPatternScale() const {
-    UBool usesPercent = fPositivePrefixPattern.usesPercent() ||
-            fPositiveSuffixPattern.usesPercent() ||
-            fNegativePrefixPattern.usesPercent() ||
-            fNegativeSuffixPattern.usesPercent();
-    if (usesPercent) {
-        return 2;
-    }
-    UBool usesPermill = fPositivePrefixPattern.usesPermill() ||
-            fPositiveSuffixPattern.usesPermill() ||
-            fNegativePrefixPattern.usesPermill() ||
-            fNegativeSuffixPattern.usesPermill();
-    if (usesPermill) {
-        return 3;
-    }
-    return 0;
-}
-
-void
-DecimalFormatImpl::setMultiplierScale(int32_t scale) {
-    if (scale == 0) {
-        // Needed to preserve equality. fMultiplier == 0 means
-        // multiplier is 1.
-        fMultiplier.set((int32_t)0);
-    } else {
-        fMultiplier.set((int32_t)1);
-        fMultiplier.shiftDecimalRight(scale);
-    }
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const {
-    FieldPositionOnlyHandler handler(pos);
-    return formatInt32(number, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatInt32(number, appendTo, handler, status);
-}
-
-template<class T>
-UBool DecimalFormatImpl::maybeFormatWithDigitList(
-        T number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    if (!fMultiplier.isZero()) {
-        DigitList digits;
-        digits.set(number);
-        digits.mult(fMultiplier, status);
-        digits.shiftDecimalRight(fScale);
-        formatAdjustedDigitList(digits, appendTo, handler, status);
-        return TRUE;
-    }
-    if (fScale != 0) {
-        DigitList digits;
-        digits.set(number);
-        digits.shiftDecimalRight(fScale);
-        formatAdjustedDigitList(digits, appendTo, handler, status);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-template<class T>
-UBool DecimalFormatImpl::maybeInitVisibleDigitsFromDigitList(
-        T number,
-        VisibleDigitsWithExponent &visibleDigits,
-        UErrorCode &status) const {
-    if (!fMultiplier.isZero()) {
-        DigitList digits;
-        digits.set(number);
-        digits.mult(fMultiplier, status);
-        digits.shiftDecimalRight(fScale);
-        initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
-        return TRUE;
-    }
-    if (fScale != 0) {
-        DigitList digits;
-        digits.set(number);
-        digits.shiftDecimalRight(fScale);
-        initVisibleDigitsFromAdjusted(digits, visibleDigits, status);
-        return TRUE;
-    }
-    return FALSE;
-}
-
-UnicodeString &
-DecimalFormatImpl::formatInt32(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    if (maybeFormatWithDigitList(number, appendTo, handler, status)) {
-        return appendTo;
-    }
-    ValueFormatter vf;
-    return fAffixes.formatInt32(
-            number,
-            prepareValueFormatter(vf),
-            handler,
-            fRules,
-            appendTo,
-            status);
-}
-
-UnicodeString &
-DecimalFormatImpl::formatInt64(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    if (number >= INT32_MIN && number <= INT32_MAX) {
-        return formatInt32((int32_t) number, appendTo, handler, status);
-    }
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    return formatVisibleDigitsWithExponent(
-            digits, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::formatDouble(
-        double number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    return formatVisibleDigitsWithExponent(
-            digits, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        double number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const {
-    FieldPositionOnlyHandler handler(pos);
-    return formatDouble(number, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        const DigitList &number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const {
-    DigitList dl(number);
-    FieldPositionOnlyHandler handler(pos);
-    return formatDigitList(dl, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const {
-    FieldPositionOnlyHandler handler(pos);
-    return formatInt64(number, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatInt64(number, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        double number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatDouble(number, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        const DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    DigitList dl(number);
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatDigitList(dl, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        StringPiece number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    DigitList dl;
-    dl.set(number, status);
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatDigitList(dl, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        const VisibleDigitsWithExponent &digits,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const {
-    FieldPositionOnlyHandler handler(pos);
-    return formatVisibleDigitsWithExponent(
-            digits, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::format(
-        const VisibleDigitsWithExponent &digits,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const {
-    FieldPositionIteratorHandler handler(posIter, status);
-    return formatVisibleDigitsWithExponent(
-            digits, appendTo, handler, status);
-}
-
-DigitList &
-DecimalFormatImpl::adjustDigitList(
-        DigitList &number, UErrorCode &status) const {
-    number.setRoundingMode(fRoundingMode);
-    if (!fMultiplier.isZero()) {
-        number.mult(fMultiplier, status);
-    }
-    if (fScale != 0) {
-        number.shiftDecimalRight(fScale);
-    }
-    number.reduce();
-    return number;
-}
-
-UnicodeString &
-DecimalFormatImpl::formatDigitList(
-        DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    initVisibleDigitsWithExponent(number, digits, status);
-    return formatVisibleDigitsWithExponent(
-            digits, appendTo, handler, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::formatAdjustedDigitList(
-        DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    ValueFormatter vf;
-    return fAffixes.format(
-            number,
-            prepareValueFormatter(vf),
-            handler,
-            fRules,
-            appendTo,
-            status);
-}
-
-UnicodeString &
-DecimalFormatImpl::formatVisibleDigitsWithExponent(
-        const VisibleDigitsWithExponent &digits,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const {
-    ValueFormatter vf;
-    return fAffixes.format(
-            digits,
-            prepareValueFormatter(vf),
-            handler,
-            fRules,
-            appendTo,
-            status);
-}
-
-static FixedDecimal &initFixedDecimal(
-        const VisibleDigits &digits, FixedDecimal &result) {
-    result.source = 0.0;
-    result.isNegative = digits.isNegative();
-    result._isNaN = digits.isNaN();
-    result._isInfinite = digits.isInfinite();
-    digits.getFixedDecimal(
-            result.source, result.intValue, result.decimalDigits,
-            result.decimalDigitsWithoutTrailingZeros,
-            result.visibleDecimalDigitCount, result.hasIntegerValue);
-    return result;
-}
-
-FixedDecimal &
-DecimalFormatImpl::getFixedDecimal(double number, FixedDecimal &result, UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return result;
-    }
-    VisibleDigits digits;
-    fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
-    return initFixedDecimal(digits, result);
-}
-
-FixedDecimal &
-DecimalFormatImpl::getFixedDecimal(
-        DigitList &number, FixedDecimal &result, UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return result;
-    }
-    VisibleDigits digits;
-    fEffPrecision.fMantissa.initVisibleDigits(number, digits, status);
-    return initFixedDecimal(digits, result);
-}
-
-VisibleDigitsWithExponent &
-DecimalFormatImpl::initVisibleDigitsWithExponent(
-        int64_t number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (maybeInitVisibleDigitsFromDigitList(
-            number, digits, status)) {
-        return digits;
-    }
-    if (fUseScientific) {
-        fEffPrecision.initVisibleDigitsWithExponent(
-                number, digits, status);
-    } else {
-        fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
-                number, digits, status);
-    }
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-DecimalFormatImpl::initVisibleDigitsWithExponent(
-        double number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (maybeInitVisibleDigitsFromDigitList(
-            number, digits, status)) {
-        return digits;
-    }
-    if (fUseScientific) {
-        fEffPrecision.initVisibleDigitsWithExponent(
-                number, digits, status);
-    } else {
-        fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
-                number, digits, status);
-    }
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-DecimalFormatImpl::initVisibleDigitsWithExponent(
-        DigitList &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    adjustDigitList(number, status);
-    return initVisibleDigitsFromAdjusted(number, digits, status);
-}
-
-VisibleDigitsWithExponent &
-DecimalFormatImpl::initVisibleDigitsFromAdjusted(
-        DigitList &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (fUseScientific) {
-        fEffPrecision.initVisibleDigitsWithExponent(
-                number, digits, status);
-    } else {
-        fEffPrecision.fMantissa.initVisibleDigitsWithExponent(
-                number, digits, status);
-    }
-    return digits;
-}
-
-DigitList &
-DecimalFormatImpl::round(
-        DigitList &number, UErrorCode &status) const {
-    if (number.isNaN() || number.isInfinite()) {
-        return number;
-    }
-    adjustDigitList(number, status);
-    ValueFormatter vf;
-    prepareValueFormatter(vf);
-    return vf.round(number, status);
-}
-
-void
-DecimalFormatImpl::setMinimumSignificantDigits(int32_t newValue) {
-    fMinSigDigits = newValue;
-    fUseSigDigits = TRUE; // ticket 9936
-    updatePrecision();
-}
-
-void
-DecimalFormatImpl::setMaximumSignificantDigits(int32_t newValue) {
-    fMaxSigDigits = newValue;
-    fUseSigDigits = TRUE; // ticket 9936
-    updatePrecision();
-}
-
-void
-DecimalFormatImpl::setMinMaxSignificantDigits(int32_t min, int32_t max) {
-    fMinSigDigits = min;
-    fMaxSigDigits = max;
-    fUseSigDigits = TRUE; // ticket 9936
-    updatePrecision();
-}
-
-void
-DecimalFormatImpl::setScientificNotation(UBool newValue) {
-    fUseScientific = newValue;
-    updatePrecision();
-}
-
-void
-DecimalFormatImpl::setSignificantDigitsUsed(UBool newValue) {
-    fUseSigDigits = newValue;
-    updatePrecision();
-}
-
-void
-DecimalFormatImpl::setGroupingSize(int32_t newValue) {
-    fGrouping.fGrouping = newValue;
-    updateGrouping();
-}
-
-void
-DecimalFormatImpl::setSecondaryGroupingSize(int32_t newValue) {
-    fGrouping.fGrouping2 = newValue;
-    updateGrouping();
-}
-
-void
-DecimalFormatImpl::setMinimumGroupingDigits(int32_t newValue) {
-    fGrouping.fMinGrouping = newValue;
-    updateGrouping();
-}
-
-void
-DecimalFormatImpl::setCurrencyUsage(
-        UCurrencyUsage currencyUsage, UErrorCode &status) {
-    fCurrencyUsage = currencyUsage;
-    updateFormatting(kFormattingCurrency, status);
-}
-
-void
-DecimalFormatImpl::setRoundingIncrement(double d) {
-    if (d > 0.0) {
-        fEffPrecision.fMantissa.fRoundingIncrement.set(d);
-    } else {
-        fEffPrecision.fMantissa.fRoundingIncrement.set(0.0);
-    }
-}
-
-double
-DecimalFormatImpl::getRoundingIncrement() const {
-    return fEffPrecision.fMantissa.fRoundingIncrement.getDouble();
-}
-
-int32_t
-DecimalFormatImpl::getMultiplier() const {
-    if (fMultiplier.isZero()) {
-        return 1;
-    }
-    return (int32_t) fMultiplier.getDouble();
-}
-
-void
-DecimalFormatImpl::setMultiplier(int32_t m) {
-    if (m == 0 || m == 1) {
-        fMultiplier.set((int32_t)0);
-    } else {
-        fMultiplier.set(m);
-    }
-}
-
-void
-DecimalFormatImpl::setPositivePrefix(const UnicodeString &str) {
-    fPositivePrefixPattern.remove();
-    fPositivePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
-    UErrorCode status = U_ZERO_ERROR;
-    updateFormatting(kFormattingPosPrefix, status);
-}
-
-void
-DecimalFormatImpl::setPositiveSuffix(const UnicodeString &str) {
-    fPositiveSuffixPattern.remove();
-    fPositiveSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
-    UErrorCode status = U_ZERO_ERROR;
-    updateFormatting(kFormattingPosSuffix, status);
-}
-
-void
-DecimalFormatImpl::setNegativePrefix(const UnicodeString &str) {
-    fNegativePrefixPattern.remove();
-    fNegativePrefixPattern.addLiteral(str.getBuffer(), 0, str.length());
-    UErrorCode status = U_ZERO_ERROR;
-    updateFormatting(kFormattingNegPrefix, status);
-}
-
-void
-DecimalFormatImpl::setNegativeSuffix(const UnicodeString &str) {
-    fNegativeSuffixPattern.remove();
-    fNegativeSuffixPattern.addLiteral(str.getBuffer(), 0, str.length());
-    UErrorCode status = U_ZERO_ERROR;
-    updateFormatting(kFormattingNegSuffix, status);
-}
-
-UnicodeString &
-DecimalFormatImpl::getPositivePrefix(UnicodeString &result) const {
-    result = fAffixes.fPositivePrefix.getOtherVariant().toString();
-    return result;
-}
-
-UnicodeString &
-DecimalFormatImpl::getPositiveSuffix(UnicodeString &result) const {
-    result = fAffixes.fPositiveSuffix.getOtherVariant().toString();
-    return result;
-}
-
-UnicodeString &
-DecimalFormatImpl::getNegativePrefix(UnicodeString &result) const {
-    result = fAffixes.fNegativePrefix.getOtherVariant().toString();
-    return result;
-}
-
-UnicodeString &
-DecimalFormatImpl::getNegativeSuffix(UnicodeString &result) const {
-    result = fAffixes.fNegativeSuffix.getOtherVariant().toString();
-    return result;
-}
-
-void
-DecimalFormatImpl::adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt) {
-    if (symbolsToAdopt == NULL) {
-        return;
-    }
-    delete fSymbols;
-    fSymbols = symbolsToAdopt;
-    UErrorCode status = U_ZERO_ERROR;
-    updateFormatting(kFormattingSymbols, status);
-}
-
-void
-DecimalFormatImpl::applyPatternFavorCurrencyPrecision(
-        const UnicodeString &pattern, UErrorCode &status) {
-    UParseError perror;
-    applyPattern(pattern, FALSE, perror, status);
-    updateForApplyPatternFavorCurrencyPrecision(status);
-}
-
-void
-DecimalFormatImpl::applyPattern(
-        const UnicodeString &pattern, UErrorCode &status) {
-    UParseError perror;
-    applyPattern(pattern, FALSE, perror, status);
-    updateForApplyPattern(status);
-}
-
-void
-DecimalFormatImpl::applyPattern(
-        const UnicodeString &pattern,
-        UParseError &perror, UErrorCode &status) {
-    applyPattern(pattern, FALSE, perror, status);
-    updateForApplyPattern(status);
-}
-
-void
-DecimalFormatImpl::applyLocalizedPattern(
-        const UnicodeString &pattern, UErrorCode &status) {
-    UParseError perror;
-    applyPattern(pattern, TRUE, perror, status);
-    updateForApplyPattern(status);
-}
-
-void
-DecimalFormatImpl::applyLocalizedPattern(
-        const UnicodeString &pattern,
-        UParseError &perror,  UErrorCode &status) {
-    applyPattern(pattern, TRUE, perror, status);
-    updateForApplyPattern(status);
-}
-
-void
-DecimalFormatImpl::applyPattern(
-        const UnicodeString &pattern,
-        UBool localized, UParseError &perror, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    DecimalFormatPatternParser patternParser;
-    if (localized) {
-        patternParser.useSymbols(*fSymbols);
-    }
-    DecimalFormatPattern out;
-    patternParser.applyPatternWithoutExpandAffix(
-            pattern, out, perror, status);
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fUseScientific = out.fUseExponentialNotation;
-    fUseSigDigits = out.fUseSignificantDigits;
-    fSuper->NumberFormat::setMinimumIntegerDigits(out.fMinimumIntegerDigits);
-    fSuper->NumberFormat::setMaximumIntegerDigits(out.fMaximumIntegerDigits);
-    fSuper->NumberFormat::setMinimumFractionDigits(out.fMinimumFractionDigits);
-    fSuper->NumberFormat::setMaximumFractionDigits(out.fMaximumFractionDigits);
-    fMinSigDigits = out.fMinimumSignificantDigits;
-    fMaxSigDigits = out.fMaximumSignificantDigits;
-    fEffPrecision.fMinExponentDigits = out.fMinExponentDigits;
-    fOptions.fExponent.fAlwaysShowSign = out.fExponentSignAlwaysShown;
-    fSuper->NumberFormat::setGroupingUsed(out.fGroupingUsed);
-    fGrouping.fGrouping = out.fGroupingSize;
-    fGrouping.fGrouping2 = out.fGroupingSize2;
-    fOptions.fMantissa.fAlwaysShowDecimal = out.fDecimalSeparatorAlwaysShown;
-    if (out.fRoundingIncrementUsed) {
-        fEffPrecision.fMantissa.fRoundingIncrement = out.fRoundingIncrement;
-    } else {
-        fEffPrecision.fMantissa.fRoundingIncrement.clear();
-    }
-    fAffixes.fPadChar = out.fPad;
-    fNegativePrefixPattern = out.fNegPrefixAffix;
-    fNegativeSuffixPattern = out.fNegSuffixAffix;
-    fPositivePrefixPattern = out.fPosPrefixAffix;
-    fPositiveSuffixPattern = out.fPosSuffixAffix;
-
-    // Work around. Pattern parsing code and DecimalFormat code don't agree
-    // on the definition of field width, so we have to translate from
-    // pattern field width to decimal format field width here.
-    fAffixes.fWidth = out.fFormatWidth == 0 ? 0 :
-            out.fFormatWidth + fPositivePrefixPattern.countChar32()
-            + fPositiveSuffixPattern.countChar32();
-    switch (out.fPadPosition) {
-    case DecimalFormatPattern::kPadBeforePrefix:
-        fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix;
-        break;
-    case DecimalFormatPattern::kPadAfterPrefix:
-        fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix;
-        break;
-    case DecimalFormatPattern::kPadBeforeSuffix:
-        fAffixes.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix;
-        break;
-    case DecimalFormatPattern::kPadAfterSuffix:
-        fAffixes.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
-        break;
-    default:
-        break;
-    }
-}
-
-void
-DecimalFormatImpl::updatePrecision() {
-    if (fUseScientific) {
-        updatePrecisionForScientific();
-    } else {
-        updatePrecisionForFixed();
-    }
-}
-
-static void updatePrecisionForScientificMinMax(
-        const DigitInterval &min,
-        const DigitInterval &max,
-        DigitInterval &resultMin,
-        DigitInterval &resultMax,
-        SignificantDigitInterval &resultSignificant) {
-    resultMin.setIntDigitCount(0);
-    resultMin.setFracDigitCount(0);
-    resultSignificant.clear();
-    resultMax.clear();
-
-    int32_t maxIntDigitCount = max.getIntDigitCount();
-    int32_t minIntDigitCount = min.getIntDigitCount();
-    int32_t maxFracDigitCount = max.getFracDigitCount();
-    int32_t minFracDigitCount = min.getFracDigitCount();
-
-
-    // Not in spec: maxIntDigitCount > 8 assume
-    // maxIntDigitCount = minIntDigitCount. Current DecimalFormat API has
-    // no provision for unsetting maxIntDigitCount which would be useful for
-    // scientific notation. The best we can do is assume that if
-    // maxIntDigitCount is the default of 2000000000 or is "big enough" then
-    // user did not intend to explicitly set it. The 8 was derived emperically
-    // by extensive testing of legacy code.
-    if (maxIntDigitCount > 8) {
-        maxIntDigitCount = minIntDigitCount;
-    }
-
-    // Per the spec, exponent grouping happens if maxIntDigitCount is more
-    // than 1 and more than minIntDigitCount.
-    UBool bExponentGrouping = maxIntDigitCount > 1 && minIntDigitCount < maxIntDigitCount;
-    if (bExponentGrouping) {
-        resultMax.setIntDigitCount(maxIntDigitCount);
-
-        // For exponent grouping minIntDigits is always treated as 1 even
-        // if it wasn't set to 1!
-        resultMin.setIntDigitCount(1);
-    } else {
-        // Fixed digit count left of decimal. minIntDigitCount doesn't have
-        // to equal maxIntDigitCount i.e minIntDigitCount == 0 while
-        // maxIntDigitCount == 1.
-        int32_t fixedIntDigitCount = maxIntDigitCount;
-
-        // If fixedIntDigitCount is 0 but
-        // min or max fraction count is 0 too then use 1. This way we can get
-        // unlimited precision for X.XXXEX
-        if (fixedIntDigitCount == 0 && (minFracDigitCount == 0 || maxFracDigitCount == 0)) {
-            fixedIntDigitCount = 1;
-        }
-        resultMax.setIntDigitCount(fixedIntDigitCount);
-        resultMin.setIntDigitCount(fixedIntDigitCount);
-    }
-    // Spec says this is how we compute significant digits. 0 means
-    // unlimited significant digits.
-    int32_t maxSigDigits = minIntDigitCount + maxFracDigitCount;
-    if (maxSigDigits > 0) {
-        int32_t minSigDigits = minIntDigitCount + minFracDigitCount;
-        resultSignificant.setMin(minSigDigits);
-        resultSignificant.setMax(maxSigDigits);
-    }
-}
-
-void
-DecimalFormatImpl::updatePrecisionForScientific() {
-    FixedPrecision *result = &fEffPrecision.fMantissa;
-    if (fUseSigDigits) {
-        result->fMax.setFracDigitCount(-1);
-        result->fMax.setIntDigitCount(1);
-        result->fMin.setFracDigitCount(0);
-        result->fMin.setIntDigitCount(1);
-        result->fSignificant.clear();
-        extractSigDigits(result->fSignificant);
-        return;
-    }
-    DigitInterval max;
-    DigitInterval min;
-    extractMinMaxDigits(min, max);
-    updatePrecisionForScientificMinMax(
-            min, max,
-            result->fMin, result->fMax, result->fSignificant);
-}
-
-void
-DecimalFormatImpl::updatePrecisionForFixed() {
-    FixedPrecision *result = &fEffPrecision.fMantissa;
-    if (!fUseSigDigits) {
-        extractMinMaxDigits(result->fMin, result->fMax);
-        result->fSignificant.clear();
-    } else {
-        extractSigDigits(result->fSignificant);
-        result->fMin.setIntDigitCount(1);
-        result->fMin.setFracDigitCount(0);
-        result->fMax.clear();
-    }
-}
-
-void
- DecimalFormatImpl::extractMinMaxDigits(
-        DigitInterval &min, DigitInterval &max) const {
-    min.setIntDigitCount(fSuper->getMinimumIntegerDigits());
-    max.setIntDigitCount(fSuper->getMaximumIntegerDigits());
-    min.setFracDigitCount(fSuper->getMinimumFractionDigits());
-    max.setFracDigitCount(fSuper->getMaximumFractionDigits());
-}
-
-void
- DecimalFormatImpl::extractSigDigits(
-        SignificantDigitInterval &sig) const {
-    sig.setMin(fMinSigDigits < 0 ? 0 : fMinSigDigits);
-    sig.setMax(fMaxSigDigits < 0 ? 0 : fMaxSigDigits);
-}
-
-void
-DecimalFormatImpl::updateGrouping() {
-    if (fSuper->isGroupingUsed()) {
-        fEffGrouping = fGrouping;
-    } else {
-        fEffGrouping.clear();
-    }
-}
-
-void
-DecimalFormatImpl::updateCurrency(UErrorCode &status) {
-    updateFormatting(kFormattingCurrency, TRUE, status);
-}
-
-void
-DecimalFormatImpl::updateFormatting(
-        int32_t changedFormattingFields,
-        UErrorCode &status) {
-    updateFormatting(changedFormattingFields, TRUE, status);
-}
-
-void
-DecimalFormatImpl::updateFormatting(
-        int32_t changedFormattingFields,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    // Each function updates one field. Order matters. For instance,
-    // updatePluralRules comes before updateCurrencyAffixInfo because the
-    // fRules field is needed to update the fCurrencyAffixInfo field.
-    updateFormattingUsesCurrency(changedFormattingFields);
-    updateFormattingFixedPointFormatter(changedFormattingFields);
-    updateFormattingAffixParser(changedFormattingFields);
-    updateFormattingPluralRules(changedFormattingFields, status);
-    updateFormattingCurrencyAffixInfo(
-            changedFormattingFields,
-            updatePrecisionBasedOnCurrency,
-            status);
-    updateFormattingLocalizedPositivePrefix(
-            changedFormattingFields, status);
-    updateFormattingLocalizedPositiveSuffix(
-            changedFormattingFields, status);
-    updateFormattingLocalizedNegativePrefix(
-            changedFormattingFields, status);
-    updateFormattingLocalizedNegativeSuffix(
-            changedFormattingFields, status);
-}
-
-void
-DecimalFormatImpl::updateFormattingUsesCurrency(
-        int32_t &changedFormattingFields) {
-    if ((changedFormattingFields & kFormattingAffixes) == 0) {
-        // If no affixes changed, don't need to do any work
-        return;
-    }
-    UBool newUsesCurrency =
-            fPositivePrefixPattern.usesCurrency() ||
-            fPositiveSuffixPattern.usesCurrency() ||
-            fNegativePrefixPattern.usesCurrency() ||
-            fNegativeSuffixPattern.usesCurrency();
-    if (fMonetary != newUsesCurrency) {
-        fMonetary = newUsesCurrency;
-        changedFormattingFields |= kFormattingUsesCurrency;
-    }
-}
-
-void
-DecimalFormatImpl::updateFormattingPluralRules(
-        int32_t &changedFormattingFields, UErrorCode &status) {
-    if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
-        // No work to do if both fSymbols and fMonetary
-        // fields are unchanged
-        return;
-    }
-    if (U_FAILURE(status)) {
-        return;
-    }
-    PluralRules *newRules = NULL;
-    if (fMonetary) {
-        newRules = PluralRules::forLocale(fSymbols->getLocale(), status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-    }
-    // Its ok to say a field has changed when it really hasn't but not
-    // the other way around. Here we assume the field changed unless it
-    // was NULL before and is still NULL now
-    if (fRules != newRules) {
-        delete fRules;
-        fRules = newRules;
-        changedFormattingFields |= kFormattingPluralRules;
-    }
-}
-
-void
-DecimalFormatImpl::updateFormattingCurrencyAffixInfo(
-        int32_t &changedFormattingFields,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status) {
-    if ((changedFormattingFields & (
-            kFormattingSymbols | kFormattingCurrency |
-            kFormattingUsesCurrency | kFormattingPluralRules)) == 0) {
-        // If all these fields are unchanged, no work to do.
-        return;
-    }
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if (!fMonetary) {
-        if (fCurrencyAffixInfo.isDefault()) {
-            // In this case don't have to do any work
-            return;
-        }
-        fCurrencyAffixInfo.set(NULL, NULL, NULL, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-        changedFormattingFields |= kFormattingCurrencyAffixInfo;
-    } else {
-        const UChar *currency = fSuper->getCurrency();
-        UChar localeCurr[4];
-        if (currency[0] == 0) {
-            ucurr_forLocale(fSymbols->getLocale().getName(), localeCurr, UPRV_LENGTHOF(localeCurr), &status);
-            if (U_SUCCESS(status)) {
-                currency = localeCurr;
-                fSuper->NumberFormat::setCurrency(currency, status);
-            } else {
-                currency = NULL;
-                status = U_ZERO_ERROR;
-            }
-        }
-        fCurrencyAffixInfo.set(
-                fSymbols->getLocale().getName(), fRules, currency, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-        UBool customCurrencySymbol = FALSE;
-        // If DecimalFormatSymbols has custom currency symbol, prefer
-        // that over what we just read from the resource bundles
-        if (fSymbols->isCustomCurrencySymbol()) {
-            fCurrencyAffixInfo.setSymbol(
-                    fSymbols->getConstSymbol(DecimalFormatSymbols::kCurrencySymbol));
-            customCurrencySymbol = TRUE;
-        }
-        if (fSymbols->isCustomIntlCurrencySymbol()) {
-            fCurrencyAffixInfo.setISO(
-                    fSymbols->getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol));
-            customCurrencySymbol = TRUE;
-        }
-        changedFormattingFields |= kFormattingCurrencyAffixInfo;
-        if (currency && !customCurrencySymbol && updatePrecisionBasedOnCurrency) {
-            FixedPrecision precision;
-            CurrencyAffixInfo::adjustPrecision(
-                    currency, fCurrencyUsage, precision, status);
-            if (U_FAILURE(status)) {
-                return;
-            }
-            fSuper->NumberFormat::setMinimumFractionDigits(
-                    precision.fMin.getFracDigitCount());
-            fSuper->NumberFormat::setMaximumFractionDigits(
-                    precision.fMax.getFracDigitCount());
-            updatePrecision();
-            fEffPrecision.fMantissa.fRoundingIncrement =
-                    precision.fRoundingIncrement;
-        }
-
-    }
-}
-
-void
-DecimalFormatImpl::updateFormattingFixedPointFormatter(
-        int32_t &changedFormattingFields) {
-    if ((changedFormattingFields & (kFormattingSymbols | kFormattingUsesCurrency)) == 0) {
-        // No work to do if fSymbols is unchanged
-        return;
-    }
-    if (fMonetary) {
-        fFormatter.setDecimalFormatSymbolsForMonetary(*fSymbols);
-    } else {
-        fFormatter.setDecimalFormatSymbols(*fSymbols);
-    }
-}
-
-void
-DecimalFormatImpl::updateFormattingAffixParser(
-        int32_t &changedFormattingFields) {
-    if ((changedFormattingFields & kFormattingSymbols) == 0) {
-        // No work to do if fSymbols is unchanged
-        return;
-    }
-    fAffixParser.setDecimalFormatSymbols(*fSymbols);
-    changedFormattingFields |= kFormattingAffixParser;
-}
-
-void
-DecimalFormatImpl::updateFormattingLocalizedPositivePrefix(
-        int32_t &changedFormattingFields, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if ((changedFormattingFields & (
-            kFormattingPosPrefix | kFormattingAffixParserWithCurrency)) == 0) {
-        // No work to do
-        return;
-    }
-    fAffixes.fPositivePrefix.remove();
-    fAffixParser.parse(
-            fPositivePrefixPattern,
-            fCurrencyAffixInfo,
-            fAffixes.fPositivePrefix,
-            status);
-}
-
-void
-DecimalFormatImpl::updateFormattingLocalizedPositiveSuffix(
-        int32_t &changedFormattingFields, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if ((changedFormattingFields & (
-            kFormattingPosSuffix | kFormattingAffixParserWithCurrency)) == 0) {
-        // No work to do
-        return;
-    }
-    fAffixes.fPositiveSuffix.remove();
-    fAffixParser.parse(
-            fPositiveSuffixPattern,
-            fCurrencyAffixInfo,
-            fAffixes.fPositiveSuffix,
-            status);
-}
-
-void
-DecimalFormatImpl::updateFormattingLocalizedNegativePrefix(
-        int32_t &changedFormattingFields, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if ((changedFormattingFields & (
-            kFormattingNegPrefix | kFormattingAffixParserWithCurrency)) == 0) {
-        // No work to do
-        return;
-    }
-    fAffixes.fNegativePrefix.remove();
-    fAffixParser.parse(
-            fNegativePrefixPattern,
-            fCurrencyAffixInfo,
-            fAffixes.fNegativePrefix,
-            status);
-}
-
-void
-DecimalFormatImpl::updateFormattingLocalizedNegativeSuffix(
-        int32_t &changedFormattingFields, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if ((changedFormattingFields & (
-            kFormattingNegSuffix | kFormattingAffixParserWithCurrency)) == 0) {
-        // No work to do
-        return;
-    }
-    fAffixes.fNegativeSuffix.remove();
-    fAffixParser.parse(
-            fNegativeSuffixPattern,
-            fCurrencyAffixInfo,
-            fAffixes.fNegativeSuffix,
-            status);
-}
-
-void
-DecimalFormatImpl::updateForApplyPatternFavorCurrencyPrecision(
-        UErrorCode &status) {
-    updateAll(kFormattingAll & ~kFormattingSymbols, TRUE, status);
-}
-
-void
-DecimalFormatImpl::updateForApplyPattern(UErrorCode &status) {
-    updateAll(kFormattingAll & ~kFormattingSymbols, FALSE, status);
-}
-
-void
-DecimalFormatImpl::updateAll(UErrorCode &status) {
-    updateAll(kFormattingAll, TRUE, status);
-}
-
-void
-DecimalFormatImpl::updateAll(
-        int32_t formattingFlags,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    updatePrecision();
-    updateGrouping();
-    updateFormatting(
-            formattingFlags, updatePrecisionBasedOnCurrency, status);
-    setMultiplierScale(getPatternScale());
-}
-
-
-static int32_t
-getMinimumLengthToDescribeGrouping(const DigitGrouping &grouping) {
-    if (grouping.fGrouping <= 0) {
-        return 0;
-    }
-    if (grouping.fGrouping2 <= 0) {
-        return grouping.fGrouping + 1;
-    }
-    return grouping.fGrouping + grouping.fGrouping2 + 1;
-}
-
-/**
- * Given a grouping policy, calculates how many digits are needed left of
- * the decimal point to achieve a desired length left of the
- * decimal point.
- * @param grouping the grouping policy
- * @param desiredLength number of characters needed left of decimal point
- * @param minLeftDigits at least this many digits is returned
- * @param leftDigits the number of digits needed stored here
- *  which is >= minLeftDigits.
- * @return true if a perfect fit or false if having leftDigits would exceed
- *   desiredLength
- */
-static UBool
-getLeftDigitsForLeftLength(
-        const DigitGrouping &grouping,
-        int32_t desiredLength,
-        int32_t minLeftDigits,
-        int32_t &leftDigits) {
-    leftDigits = minLeftDigits;
-    int32_t lengthSoFar = leftDigits + grouping.getSeparatorCount(leftDigits);
-    while (lengthSoFar < desiredLength) {
-        lengthSoFar += grouping.isSeparatorAt(leftDigits + 1, leftDigits) ? 2 : 1;
-        ++leftDigits;
-    }
-    return (lengthSoFar == desiredLength);
-}
-
-int32_t
-DecimalFormatImpl::computeExponentPatternLength() const {
-    if (fUseScientific) {
-        return 1 + (fOptions.fExponent.fAlwaysShowSign ? 1 : 0) + fEffPrecision.fMinExponentDigits;
-    }
-    return 0;
-}
-
-int32_t
-DecimalFormatImpl::countFractionDigitAndDecimalPatternLength(
-        int32_t fracDigitCount) const {
-    if (!fOptions.fMantissa.fAlwaysShowDecimal && fracDigitCount == 0) {
-        return 0;
-    }
-    return fracDigitCount + 1;
-}
-
-UnicodeString&
-DecimalFormatImpl::toNumberPattern(
-        UBool hasPadding, int32_t minimumLength, UnicodeString& result) const {
-    // Get a grouping policy like the one in this object that does not
-    // have minimum grouping since toPattern doesn't support it.
-    DigitGrouping grouping(fEffGrouping);
-    grouping.fMinGrouping = 0;
-
-    // Only for fixed digits, these are the digits that get 0's.
-    DigitInterval minInterval;
-
-    // Only for fixed digits, these are the digits that get #'s.
-    DigitInterval maxInterval;
-
-    // Only for significant digits
-    int32_t sigMin = 0; /* initialize to avoid compiler warning */
-    int32_t sigMax = 0; /* initialize to avoid compiler warning */
-
-    // These are all the digits to be displayed. For significant digits,
-    // this interval always starts at the 1's place an extends left.
-    DigitInterval fullInterval;
-
-    // Digit range of rounding increment. If rounding increment is .025.
-    // then roundingIncrementLowerExp = -3 and roundingIncrementUpperExp = -1
-    int32_t roundingIncrementLowerExp = 0;
-    int32_t roundingIncrementUpperExp = 0;
-
-    if (fUseSigDigits) {
-        SignificantDigitInterval sigInterval;
-        extractSigDigits(sigInterval);
-        sigMax = sigInterval.getMax();
-        sigMin = sigInterval.getMin();
-        fullInterval.setFracDigitCount(0);
-        fullInterval.setIntDigitCount(sigMax);
-    } else {
-        extractMinMaxDigits(minInterval, maxInterval);
-        if (fUseScientific) {
-           if (maxInterval.getIntDigitCount() > kMaxScientificIntegerDigits) {
-               maxInterval.setIntDigitCount(1);
-               minInterval.shrinkToFitWithin(maxInterval);
-           }
-        } else if (hasPadding) {
-            // Make max int digits match min int digits for now, we
-            // compute necessary padding later.
-            maxInterval.setIntDigitCount(minInterval.getIntDigitCount());
-        } else {
-            // For some reason toPattern adds at least one leading '#'
-            maxInterval.setIntDigitCount(minInterval.getIntDigitCount() + 1);
-        }
-        if (!fEffPrecision.fMantissa.fRoundingIncrement.isZero()) {
-            roundingIncrementLowerExp =
-                    fEffPrecision.fMantissa.fRoundingIncrement.getLowerExponent();
-            roundingIncrementUpperExp =
-                    fEffPrecision.fMantissa.fRoundingIncrement.getUpperExponent();
-            // We have to include the rounding increment in what we display
-            maxInterval.expandToContainDigit(roundingIncrementLowerExp);
-            maxInterval.expandToContainDigit(roundingIncrementUpperExp - 1);
-        }
-        fullInterval = maxInterval;
-    }
-    // We have to include enough digits to show grouping strategy
-    int32_t minLengthToDescribeGrouping =
-           getMinimumLengthToDescribeGrouping(grouping);
-    if (minLengthToDescribeGrouping > 0) {
-        fullInterval.expandToContainDigit(
-                getMinimumLengthToDescribeGrouping(grouping) - 1);
-    }
-
-    // If we have a minimum length, we have to add digits to the left to
-    // depict padding.
-    if (hasPadding) {
-        // For non scientific notation,
-        //  minimumLengthForMantissa = minimumLength
-        int32_t minimumLengthForMantissa =
-                minimumLength - computeExponentPatternLength();
-        int32_t mininumLengthForMantissaIntPart =
-                minimumLengthForMantissa
-                - countFractionDigitAndDecimalPatternLength(
-                        fullInterval.getFracDigitCount());
-        // Because of grouping, we may need fewer than expected digits to
-        // achieve the length we need.
-        int32_t digitsNeeded;
-        if (getLeftDigitsForLeftLength(
-                grouping,
-                mininumLengthForMantissaIntPart,
-                fullInterval.getIntDigitCount(),
-                digitsNeeded)) {
-
-            // In this case, we achieved the exact length that we want.
-            fullInterval.setIntDigitCount(digitsNeeded);
-        } else if (digitsNeeded > fullInterval.getIntDigitCount()) {
-
-            // Having digitsNeeded digits goes over desired length which
-            // means that to have desired length would mean starting on a
-            // grouping sepearator e.g ,###,### so add a '#' and use one
-            // less digit. This trick gives ####,### but that is the best
-            // we can do.
-            result.append(kPatternDigit);
-            fullInterval.setIntDigitCount(digitsNeeded - 1);
-        }
-    }
-    int32_t maxDigitPos = fullInterval.getMostSignificantExclusive();
-    int32_t minDigitPos = fullInterval.getLeastSignificantInclusive();
-    for (int32_t i = maxDigitPos - 1; i >= minDigitPos; --i) {
-        if (!fOptions.fMantissa.fAlwaysShowDecimal && i == -1) {
-            result.append(kPatternDecimalSeparator);
-        }
-        if (fUseSigDigits) {
-            // Use digit symbol
-            if (i >= sigMax || i < sigMax - sigMin) {
-                result.append(kPatternDigit);
-            } else {
-                result.append(kPatternSignificantDigit);
-            }
-        } else {
-            if (i < roundingIncrementUpperExp && i >= roundingIncrementLowerExp) {
-                result.append((UChar)(fEffPrecision.fMantissa.fRoundingIncrement.getDigitByExponent(i) + kPatternZeroDigit));
-            } else if (minInterval.contains(i)) {
-                result.append(kPatternZeroDigit);
-            } else {
-                result.append(kPatternDigit);
-            }
-        }
-        if (grouping.isSeparatorAt(i + 1, i)) {
-            result.append(kPatternGroupingSeparator);
-        }
-        if (fOptions.fMantissa.fAlwaysShowDecimal && i == 0) {
-            result.append(kPatternDecimalSeparator);
-        }
-    }
-    if (fUseScientific) {
-        result.append(kPatternExponent);
-        if (fOptions.fExponent.fAlwaysShowSign) {
-            result.append(kPatternPlus);
-        }
-        for (int32_t i = 0; i < 1 || i < fEffPrecision.fMinExponentDigits; ++i) {
-            result.append(kPatternZeroDigit);
-        }
-    }
-    return result;
-}
-
-UnicodeString&
-DecimalFormatImpl::toPattern(UnicodeString& result) const {
-    result.remove();
-    UnicodeString padSpec;
-    if (fAffixes.fWidth > 0) {
-        padSpec.append(kPatternPadEscape);
-        padSpec.append(fAffixes.fPadChar);
-    }
-    if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
-        result.append(padSpec);
-    }
-    fPositivePrefixPattern.toUserString(result);
-    if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
-        result.append(padSpec);
-    }
-    toNumberPattern(
-            fAffixes.fWidth > 0,
-            fAffixes.fWidth - fPositivePrefixPattern.countChar32() - fPositiveSuffixPattern.countChar32(),
-            result);
-    if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
-        result.append(padSpec);
-    }
-    fPositiveSuffixPattern.toUserString(result);
-    if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
-        result.append(padSpec);
-    }
-    AffixPattern withNegative;
-    withNegative.add(AffixPattern::kNegative);
-    withNegative.append(fPositivePrefixPattern);
-    if (!fPositiveSuffixPattern.equals(fNegativeSuffixPattern) ||
-            !withNegative.equals(fNegativePrefixPattern)) {
-        result.append(kPatternSeparator);
-        if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforePrefix) {
-            result.append(padSpec);
-        }
-        fNegativePrefixPattern.toUserString(result);
-        if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterPrefix) {
-            result.append(padSpec);
-        }
-        toNumberPattern(
-                fAffixes.fWidth > 0,
-                fAffixes.fWidth - fNegativePrefixPattern.countChar32() - fNegativeSuffixPattern.countChar32(),
-                result);
-        if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadBeforeSuffix) {
-            result.append(padSpec);
-        }
-        fNegativeSuffixPattern.toUserString(result);
-        if (fAffixes.fPadPosition == DigitAffixesAndPadding::kPadAfterSuffix) {
-            result.append(padSpec);
-        }
-    }
-    return result;
-}
-
-int32_t
-DecimalFormatImpl::getOldFormatWidth() const {
-    if (fAffixes.fWidth == 0) {
-        return 0;
-    }
-    return fAffixes.fWidth - fPositiveSuffixPattern.countChar32() - fPositivePrefixPattern.countChar32();
-}
-
-const UnicodeString &
-DecimalFormatImpl::getConstSymbol(
-        DecimalFormatSymbols::ENumberFormatSymbol symbol) const {
-   return fSymbols->getConstSymbol(symbol);
-}
-
-UBool
-DecimalFormatImpl::isParseFastpath() const {
-    AffixPattern negative;
-    negative.add(AffixPattern::kNegative);
-
-    return fAffixes.fWidth == 0 &&
-    fPositivePrefixPattern.countChar32() == 0 &&
-    fNegativePrefixPattern.equals(negative) &&
-    fPositiveSuffixPattern.countChar32() == 0 &&
-    fNegativeSuffixPattern.countChar32() == 0;
-}
-
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/decimfmtimpl.h b/deps/icu-small/source/i18n/decimfmtimpl.h
deleted file mode 100644
index b4438cba9e1ea8..00000000000000
--- a/deps/icu-small/source/i18n/decimfmtimpl.h
+++ /dev/null
@@ -1,549 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-********************************************************************************
-*   Copyright (C) 2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-********************************************************************************
-*
-* File decimfmtimpl.h
-********************************************************************************
-*/
-
-#ifndef DECIMFMTIMPL_H
-#define DECIMFMTIMPL_H
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/decimfmt.h"
-#include "unicode/uobject.h"
-#include "affixpatternparser.h"
-#include "digitaffixesandpadding.h"
-#include "digitformatter.h"
-#include "digitgrouping.h"
-#include "precision.h"
-
-U_NAMESPACE_BEGIN
-
-class UnicodeString;
-class FieldPosition;
-class ValueFormatter;
-class FieldPositionHandler;
-class FixedDecimal;
-
-/**
- * DecimalFormatImpl is the glue code between the legacy DecimalFormat class
- * and the new decimal formatting classes. DecimalFormat still handles
- * parsing directly. However, DecimalFormat uses attributes of this class
- * for parsing when possible.
- *
- * The public API of this class closely mirrors the legacy API of the
- * legacy DecimalFormat deviating only when the legacy API does not make
- * sense. For example, although DecimalFormat has a
- * getPadCharacterString() method, DecimalFormatImpl has a getPadCharacter()
- * method because formatting uses only a single pad character for padding.
- *
- * Each legacy DecimalFormat instance heap allocates its own instance of
- * this class. Most DecimalFormat methods that deal with formatting simply
- * delegate to the DecimalFormat's DecimalFormatImpl method.
- *
- * Because DecimalFormat extends NumberFormat, Each instance of this class
- * "borrows" a pointer to the NumberFormat part of its enclosing DecimalFormat
- * instance. This way each DecimalFormatImpl instance can read or even modify
- * the NumberFormat portion of its enclosing DecimalFormat instance.
- *
- * Directed acyclic graph (DAG):
- *
- * This class can be represented as a directed acyclic graph (DAG) where each
- * vertex is an attribute, and each directed edge indicates that the value
- * of the destination attribute is calculated from the value of the source
- * attribute. Attributes with setter methods reside at the bottom of the
- * DAG. That is, no edges point to them. We call these independent attributes
- * because their values can be set independently of one another. The rest of
- * the attributes are derived attributes because their values depend on the
- * independent attributes. DecimalFormatImpl often uses the derived
- * attributes, not the independent attributes, when formatting numbers.
- *
- * The independent attributes at the bottom of the DAG correspond to the legacy
- * attributes of DecimalFormat while the attributes at the top of the DAG
- * correspond to the attributes of the new code. The edges of the DAG
- * correspond to the code that handles the complex interaction among all the
- * legacy attributes of the DecimalFormat API.
- *
- * We use a DAG for three reasons.
- *
- * First, the DAG preserves backward compatibility. Clients of the legacy
- * DecimalFormat expect existing getters and setters of each attribute to be
- * consistent. That means if a client sets a particular attribute to a new
- * value, the attribute should retain that value until the client sets it to
- * a new value. The DAG allows these attributes to remain consistent even
- * though the new code may not use them when formatting.
- *
- * Second, the DAG obviates the need to recalculate derived attributes with
- * each format. Instead, the DAG "remembers" the values of all derived
- * attributes. Only setting an independent attribute requires a recalculation.
- * Moreover, setting an independent attribute recalculates only the affected
- * dependent attributes rather than all dependent attributes.
- *
- * Third, the DAG abstracts away the complex interaction among the legacy
- * attributes of the DecimalFormat API.
- *
- * Only the independent attributes of the DAG have setters and getters.
- * Derived attributes have no setters (and often no getters either).
- *
- * Copy and assign:
- *
- * For copy and assign, DecimalFormatImpl copies and assigns every attribute
- * regardless of whether or not it is independent. We do this for simplicity.
- *
- * Implementation of the DAG:
- *
- * The DAG consists of three smaller DAGs:
- * 1. Grouping attributes
- * 2. Precision attributes
- * 3. Formatting attributes.
- *
- * The first two DAGs are simple in that setting any independent attribute
- * in the DAG recalculates all the dependent attributes in that DAG.
- * The updateGrouping() and updatePrecision() perform the respective
- * recalculations.
- *
- * Because some of the derived formatting attributes are expensive to
- * calculate, the formatting attributes DAG is more complex. The
- * updateFormatting() method is composed of many updateFormattingXXX()
- * methods, each of which recalculates a single derived attribute. The
- * updateFormatting() method accepts a bitfield of recently changed
- * attributes and passes this bitfield by reference to each of the
- * updateFormattingXXX() methods. Each updateFormattingXXX() method checks
- * the bitfield to see if any of the attributes it uses to compute the XXX
- * attribute changed. If none of them changed, it exists immediately. However,
- * if at least one of them changed, it recalculates the XXX attribute and
- * sets the corresponding bit in the bitfield. In this way, each
- * updateFormattingXXX() method encodes the directed edges in the formatting
- * DAG that point to the attribute its calculating.
- *
- * Maintenance of the updateFormatting() method.
- *
- * Use care when changing the updateFormatting() method.
- * The updateFormatting() method must call each updateFormattingXXX() in the
- * same partial order that the formatting DAG prescribes. That is, the
- * attributes near the bottom of the DAG must be calculated before attributes
- * further up. As we mentioned in the prvious paragraph, the directed edges of
- * the formatting DAG are encoded within each updateFormattingXXX() method.
- * Finally, adding new attributes may involve adding to the bitmap that the
- * updateFormatting() method uses. The top most attributes in the DAG,
- * those that do not point to any attributes but only have attributes
- * pointing to it, need not have a slot in the bitmap.
- *
- * Keep in mind that most of the code that makes the legacy DecimalFormat API
- * work the way it always has before can be found in these various updateXXX()
- * methods. For example the updatePrecisionForScientific() method
- * handles the complex interactions amoung the various precision attributes
- * when formatting in scientific notation. Changing the way attributes
- * interract, often means changing one of these updateXXX() methods.
- *
- * Conclusion:
- *
- * The DecimFmtImpl class is the glue code between the legacy and new
- * number formatting code. It uses a direct acyclic graph (DAG) to
- * maintain backward compatibility, to make the code efficient, and to
- * abstract away the complex interraction among legacy attributs.
- */
-
-
-class DecimalFormatImpl : public UObject {
-public:
-
-DecimalFormatImpl(
-        NumberFormat *super,
-        const Locale &locale,
-        const UnicodeString &pattern,
-        UErrorCode &status);
-DecimalFormatImpl(
-        NumberFormat *super,
-        const UnicodeString &pattern,
-        DecimalFormatSymbols *symbolsToAdopt,
-        UParseError &parseError,
-        UErrorCode &status);
-DecimalFormatImpl(
-        NumberFormat *super,
-        const DecimalFormatImpl &other,
-        UErrorCode &status);
-DecimalFormatImpl &assign(
-        const DecimalFormatImpl &other, UErrorCode &status);
-virtual ~DecimalFormatImpl();
-void adoptDecimalFormatSymbols(DecimalFormatSymbols *symbolsToAdopt);
-const DecimalFormatSymbols &getDecimalFormatSymbols() const {
-    return *fSymbols;
-}
-UnicodeString &format(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const;
-UnicodeString &format(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-UnicodeString &format(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const;
-UnicodeString &format(
-        double number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const;
-UnicodeString &format(
-        const DigitList &number,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const;
-UnicodeString &format(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-UnicodeString &format(
-        double number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-UnicodeString &format(
-        const DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-UnicodeString &format(
-        StringPiece number,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-UnicodeString &format(
-        const VisibleDigitsWithExponent &digits,
-        UnicodeString &appendTo,
-        FieldPosition &pos,
-        UErrorCode &status) const;
-UnicodeString &format(
-        const VisibleDigitsWithExponent &digits,
-        UnicodeString &appendTo,
-        FieldPositionIterator *posIter,
-        UErrorCode &status) const;
-
-UBool operator==(const DecimalFormatImpl &) const;
-
-UBool operator!=(const DecimalFormatImpl &other) const {
-    return !(*this == other);
-}
-
-void setRoundingMode(DecimalFormat::ERoundingMode mode) {
-    fRoundingMode = mode;
-    fEffPrecision.fMantissa.fExactOnly = (fRoundingMode == DecimalFormat::kRoundUnnecessary);
-    fEffPrecision.fMantissa.fRoundingMode = mode;
-}
-DecimalFormat::ERoundingMode getRoundingMode() const {
-    return fRoundingMode;
-}
-void setFailIfMoreThanMaxDigits(UBool b) {
-    fEffPrecision.fMantissa.fFailIfOverMax = b;
-}
-UBool isFailIfMoreThanMaxDigits() const { return fEffPrecision.fMantissa.fFailIfOverMax; }
-void setMinimumSignificantDigits(int32_t newValue);
-void setMaximumSignificantDigits(int32_t newValue);
-void setMinMaxSignificantDigits(int32_t min, int32_t max);
-void setScientificNotation(UBool newValue);
-void setSignificantDigitsUsed(UBool newValue);
-
-int32_t getMinimumSignificantDigits() const {
-        return fMinSigDigits; }
-int32_t getMaximumSignificantDigits() const {
-        return fMaxSigDigits; }
-UBool isScientificNotation() const { return fUseScientific; }
-UBool areSignificantDigitsUsed() const { return fUseSigDigits; }
-void setGroupingSize(int32_t newValue);
-void setSecondaryGroupingSize(int32_t newValue);
-void setMinimumGroupingDigits(int32_t newValue);
-int32_t getGroupingSize() const { return fGrouping.fGrouping; }
-int32_t getSecondaryGroupingSize() const { return fGrouping.fGrouping2; }
-int32_t getMinimumGroupingDigits() const { return fGrouping.fMinGrouping; }
-void applyPattern(const UnicodeString &pattern, UErrorCode &status);
-void applyPatternFavorCurrencyPrecision(
-        const UnicodeString &pattern, UErrorCode &status);
-void applyPattern(
-        const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
-void applyLocalizedPattern(const UnicodeString &pattern, UErrorCode &status);
-void applyLocalizedPattern(
-        const UnicodeString &pattern, UParseError &perror, UErrorCode &status);
-void setCurrencyUsage(UCurrencyUsage usage, UErrorCode &status);
-UCurrencyUsage getCurrencyUsage() const { return fCurrencyUsage; }
-void setRoundingIncrement(double d);
-double getRoundingIncrement() const;
-int32_t getMultiplier() const;
-void setMultiplier(int32_t m);
-UChar32 getPadCharacter() const { return fAffixes.fPadChar; }
-void setPadCharacter(UChar32 c) { fAffixes.fPadChar = c; }
-int32_t getFormatWidth() const { return fAffixes.fWidth; }
-void setFormatWidth(int32_t x) { fAffixes.fWidth = x; }
-DigitAffixesAndPadding::EPadPosition getPadPosition() const {
-    return fAffixes.fPadPosition;
-}
-void setPadPosition(DigitAffixesAndPadding::EPadPosition x) {
-    fAffixes.fPadPosition = x;
-}
-int32_t getMinimumExponentDigits() const {
-    return fEffPrecision.fMinExponentDigits;
-}
-void setMinimumExponentDigits(int32_t x) {
-    fEffPrecision.fMinExponentDigits = x;
-}
-UBool isExponentSignAlwaysShown() const {
-    return fOptions.fExponent.fAlwaysShowSign;
-}
-void setExponentSignAlwaysShown(UBool x) {
-    fOptions.fExponent.fAlwaysShowSign = x;
-}
-UBool isDecimalSeparatorAlwaysShown() const {
-    return fOptions.fMantissa.fAlwaysShowDecimal;
-}
-void setDecimalSeparatorAlwaysShown(UBool x) {
-    fOptions.fMantissa.fAlwaysShowDecimal = x;
-}
-UnicodeString &getPositivePrefix(UnicodeString &result) const;
-UnicodeString &getPositiveSuffix(UnicodeString &result) const;
-UnicodeString &getNegativePrefix(UnicodeString &result) const;
-UnicodeString &getNegativeSuffix(UnicodeString &result) const;
-void setPositivePrefix(const UnicodeString &str);
-void setPositiveSuffix(const UnicodeString &str);
-void setNegativePrefix(const UnicodeString &str);
-void setNegativeSuffix(const UnicodeString &str);
-UnicodeString &toPattern(UnicodeString& result) const;
-FixedDecimal &getFixedDecimal(double value, FixedDecimal &result, UErrorCode &status) const;
-FixedDecimal &getFixedDecimal(DigitList &number, FixedDecimal &result, UErrorCode &status) const;
-DigitList &round(DigitList &number, UErrorCode &status) const;
-
-VisibleDigitsWithExponent &
-initVisibleDigitsWithExponent(
-        int64_t number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const;
-VisibleDigitsWithExponent &
-initVisibleDigitsWithExponent(
-        double number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const;
-VisibleDigitsWithExponent &
-initVisibleDigitsWithExponent(
-        DigitList &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const;
-
-void updatePrecision();
-void updateGrouping();
-void updateCurrency(UErrorCode &status);
-
-
-private:
-// Disallow copy and assign
-DecimalFormatImpl(const DecimalFormatImpl &other);
-DecimalFormatImpl &operator=(const DecimalFormatImpl &other);
-NumberFormat *fSuper;
-DigitList fMultiplier;
-int32_t fScale;
-
-DecimalFormat::ERoundingMode fRoundingMode;
-
-// These fields include what the user can see and set.
-// When the user updates these fields, it triggers automatic updates of
-// other fields that may be invisible to user
-
-// Updating any of the following fields triggers an update to
-// fEffPrecision.fMantissa.fMin,
-// fEffPrecision.fMantissa.fMax,
-// fEffPrecision.fMantissa.fSignificant fields
-// We have this two phase update because of backward compatibility.
-// DecimalFormat has to remember all settings even if those settings are
-// invalid or disabled.
-int32_t fMinSigDigits;
-int32_t fMaxSigDigits;
-UBool fUseScientific;
-UBool fUseSigDigits;
-// In addition to these listed above, changes to min/max int digits and
-// min/max frac digits from fSuper also trigger an update.
-
-// Updating any of the following fields triggers an update to
-// fEffGrouping field Again we do it this way because original
-// grouping settings have to be retained if grouping is turned off.
-DigitGrouping fGrouping;
-// In addition to these listed above, changes to isGroupingUsed in
-// fSuper also triggers an update to fEffGrouping.
-
-// Updating any of the following fields triggers updates on the following:
-// fMonetary, fRules, fAffixParser, fCurrencyAffixInfo,
-// fFormatter, fAffixes.fPositivePrefiix, fAffixes.fPositiveSuffix,
-// fAffixes.fNegativePrefiix, fAffixes.fNegativeSuffix
-// We do this two phase update because localizing the affix patterns
-// and formatters can be expensive. Better to do it once with the setters
-// than each time within format.
-AffixPattern fPositivePrefixPattern;
-AffixPattern fNegativePrefixPattern;
-AffixPattern fPositiveSuffixPattern;
-AffixPattern fNegativeSuffixPattern;
-DecimalFormatSymbols *fSymbols;
-UCurrencyUsage fCurrencyUsage;
-// In addition to these listed above, changes to getCurrency() in
-// fSuper also triggers an update.
-
-// Optional may be NULL
-PluralRules *fRules;
-
-// These fields are totally hidden from user and are used to derive the affixes
-// in fAffixes below from the four affix patterns above.
-UBool fMonetary;
-AffixPatternParser fAffixParser;
-CurrencyAffixInfo fCurrencyAffixInfo;
-
-// The actual precision used when formatting
-ScientificPrecision fEffPrecision;
-
-// The actual grouping used when formatting
-DigitGrouping fEffGrouping;
-SciFormatterOptions fOptions;   // Encapsulates fixed precision options
-DigitFormatter fFormatter;
-DigitAffixesAndPadding fAffixes;
-
-UnicodeString &formatInt32(
-        int32_t number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-UnicodeString &formatInt64(
-        int64_t number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-UnicodeString &formatDouble(
-        double number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-// Scales for precent or permille symbols
-UnicodeString &formatDigitList(
-        DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-// Does not scale for precent or permille symbols
-UnicodeString &formatAdjustedDigitList(
-        DigitList &number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-UnicodeString &formatVisibleDigitsWithExponent(
-        const VisibleDigitsWithExponent &number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-VisibleDigitsWithExponent &
-initVisibleDigitsFromAdjusted(
-        DigitList &number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const;
-
-template<class T>
-UBool maybeFormatWithDigitList(
-        T number,
-        UnicodeString &appendTo,
-        FieldPositionHandler &handler,
-        UErrorCode &status) const;
-
-template<class T>
-UBool maybeInitVisibleDigitsFromDigitList(
-        T number,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const;
-
-DigitList &adjustDigitList(DigitList &number, UErrorCode &status) const;
-
-void applyPattern(
-        const UnicodeString &pattern,
-        UBool localized, UParseError &perror, UErrorCode &status);
-
-ValueFormatter &prepareValueFormatter(ValueFormatter &vf) const;
-void setMultiplierScale(int32_t s);
-int32_t getPatternScale() const;
-void setScale(int32_t s) { fScale = s; }
-int32_t getScale() const { return fScale; }
-
-// Updates everything
-void updateAll(UErrorCode &status);
-void updateAll(
-        int32_t formattingFlags,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status);
-
-// Updates from formatting pattern changes
-void updateForApplyPattern(UErrorCode &status);
-void updateForApplyPatternFavorCurrencyPrecision(UErrorCode &status);
-
-// Updates from changes to third group of attributes
-void updateFormatting(int32_t changedFormattingFields, UErrorCode &status);
-void updateFormatting(
-        int32_t changedFormattingFields,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status);
-
-// Helper functions for updatePrecision
-void updatePrecisionForScientific();
-void updatePrecisionForFixed();
-void extractMinMaxDigits(DigitInterval &min, DigitInterval &max) const;
-void extractSigDigits(SignificantDigitInterval &sig) const;
-
-// Helper functions for updateFormatting
-void updateFormattingUsesCurrency(int32_t &changedFormattingFields);
-void updateFormattingPluralRules(
-        int32_t &changedFormattingFields, UErrorCode &status);
-void updateFormattingAffixParser(int32_t &changedFormattingFields);
-void updateFormattingCurrencyAffixInfo(
-        int32_t &changedFormattingFields,
-        UBool updatePrecisionBasedOnCurrency,
-        UErrorCode &status);
-void updateFormattingFixedPointFormatter(
-        int32_t &changedFormattingFields);
-void updateFormattingLocalizedPositivePrefix(
-        int32_t &changedFormattingFields, UErrorCode &status);
-void updateFormattingLocalizedPositiveSuffix(
-        int32_t &changedFormattingFields, UErrorCode &status);
-void updateFormattingLocalizedNegativePrefix(
-        int32_t &changedFormattingFields, UErrorCode &status);
-void updateFormattingLocalizedNegativeSuffix(
-        int32_t &changedFormattingFields, UErrorCode &status);
-
-int32_t computeExponentPatternLength() const;
-int32_t countFractionDigitAndDecimalPatternLength(int32_t fracDigitCount) const;
-UnicodeString &toNumberPattern(
-        UBool hasPadding, int32_t minimumLength, UnicodeString& result) const;
-
-int32_t getOldFormatWidth() const;
-const UnicodeString &getConstSymbol(
-        DecimalFormatSymbols::ENumberFormatSymbol symbol) const;
-UBool isParseFastpath() const;
-
-friend class DecimalFormat;
-
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif // DECIMFMTIMPL_H
-//eof
diff --git a/deps/icu-small/source/i18n/digitaffix.cpp b/deps/icu-small/source/i18n/digitaffix.cpp
deleted file mode 100644
index 396df2cf1d75eb..00000000000000
--- a/deps/icu-small/source/i18n/digitaffix.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: digitaffix.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "digitaffix.h"
-#include "fphdlimp.h"
-#include "uassert.h"
-#include "unistrappender.h"
-
-U_NAMESPACE_BEGIN
-
-DigitAffix::DigitAffix() : fAffix(), fAnnotations() {
-}
-
-DigitAffix::DigitAffix(
-        const UChar *value, int32_t charCount, int32_t fieldId)
-        : fAffix(value, charCount),
-          fAnnotations(charCount, (UChar) fieldId, charCount) {
-}
-
-void
-DigitAffix::remove() {
-    fAffix.remove();
-    fAnnotations.remove();
-}
-
-void
-DigitAffix::appendUChar(UChar value, int32_t fieldId) {
-    fAffix.append(value);
-    fAnnotations.append((UChar) fieldId);
-}
-
-void
-DigitAffix::append(const UnicodeString &value, int32_t fieldId) {
-    fAffix.append(value);
-    {
-        UnicodeStringAppender appender(fAnnotations);
-        int32_t len = value.length();
-        for (int32_t i = 0; i < len; ++i) {
-            appender.append((UChar) fieldId);
-        }
-    }
-}
-
-void
-DigitAffix::setTo(const UnicodeString &value, int32_t fieldId) {
-    fAffix = value;
-    fAnnotations.remove();
-    {
-        UnicodeStringAppender appender(fAnnotations);
-        int32_t len = value.length();
-        for (int32_t i = 0; i < len; ++i) {
-            appender.append((UChar) fieldId);
-        }
-    }
-}
-
-void
-DigitAffix::append(const UChar *value, int32_t charCount, int32_t fieldId) {
-    fAffix.append(value, charCount);
-    {
-        UnicodeStringAppender appender(fAnnotations);
-        for (int32_t i = 0; i < charCount; ++i) {
-            appender.append((UChar) fieldId);
-        }
-    }
-}
-
-UnicodeString &
-DigitAffix::format(FieldPositionHandler &handler, UnicodeString &appendTo) const {
-    int32_t len = fAffix.length();
-    if (len == 0) {
-        return appendTo;
-    }
-    if (!handler.isRecording()) {
-        return appendTo.append(fAffix);
-    }
-    U_ASSERT(fAffix.length() == fAnnotations.length());
-    int32_t appendToStart = appendTo.length();
-    int32_t lastId = (int32_t) fAnnotations.charAt(0);
-    int32_t lastIdStart = 0;
-    for (int32_t i = 1; i < len; ++i) {
-        int32_t id = (int32_t) fAnnotations.charAt(i);
-        if (id != lastId) {
-            if (lastId != UNUM_FIELD_COUNT) {
-                handler.addAttribute(lastId, appendToStart + lastIdStart, appendToStart + i);
-            }
-            lastId = id;
-            lastIdStart = i;
-        }
-    }
-    if (lastId != UNUM_FIELD_COUNT) {
-        handler.addAttribute(lastId, appendToStart + lastIdStart, appendToStart + len);
-    }
-    return appendTo.append(fAffix);
-}
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/digitaffix.h b/deps/icu-small/source/i18n/digitaffix.h
deleted file mode 100644
index 005c36f8488d8f..00000000000000
--- a/deps/icu-small/source/i18n/digitaffix.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* digitaffix.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __DIGITAFFIX_H__
-#define __DIGITAFFIX_H__
-
-#include "unicode/uobject.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/unistr.h"
-#include "unicode/unum.h"
-#include "unicode/utypes.h"
-
-U_NAMESPACE_BEGIN
-
-class FieldPositionHandler;
-
-/**
- * A prefix or suffix of a formatted number.
- */
-class U_I18N_API DigitAffix : public UMemory {
-public:
-
-    /**
-     * Creates an empty DigitAffix.
-     */
-    DigitAffix();
-
-    /**
-     * Creates a DigitAffix containing given UChars where all of it has
-     * a field type of fieldId.
-     */
-    DigitAffix(
-            const UChar *value,
-            int32_t charCount,
-            int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Makes this affix be the empty string.
-     */
-    void remove();
-
-    /**
-     * Append value to this affix. If fieldId is present, the appended
-     * string is considered to be the type fieldId.
-     */
-    void appendUChar(UChar value, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Append value to this affix. If fieldId is present, the appended
-     * string is considered to be the type fieldId.
-     */
-    void append(const UnicodeString &value, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Sets this affix to given string. The entire string
-     * is considered to be the type fieldId.
-     */
-    void setTo(const UnicodeString &value, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Append value to this affix. If fieldId is present, the appended
-     * string is considered to be the type fieldId.
-     */
-    void append(const UChar *value, int32_t charCount, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Formats this affix.
-     */
-    UnicodeString &format(
-            FieldPositionHandler &handler, UnicodeString &appendTo) const;
-    int32_t countChar32() const { return fAffix.countChar32(); }
-
-    /**
-     * Returns this affix as a unicode string.
-     */
-    const UnicodeString & toString() const { return fAffix; }
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const DigitAffix &rhs) const {
-        return ((fAffix == rhs.fAffix) && (fAnnotations == rhs.fAnnotations));
-    }
-private:
-    UnicodeString fAffix;
-    UnicodeString fAnnotations;
-};
-
-
-U_NAMESPACE_END
-#endif // #if !UCONFIG_NO_FORMATTING
-#endif  // __DIGITAFFIX_H__
diff --git a/deps/icu-small/source/i18n/digitaffixesandpadding.cpp b/deps/icu-small/source/i18n/digitaffixesandpadding.cpp
deleted file mode 100644
index 487d9a345d3e21..00000000000000
--- a/deps/icu-small/source/i18n/digitaffixesandpadding.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: digitaffixesandpadding.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/plurrule.h"
-#include "charstr.h"
-#include "digitaffix.h"
-#include "digitaffixesandpadding.h"
-#include "digitlst.h"
-#include "uassert.h"
-#include "valueformatter.h"
-#include "visibledigits.h"
-
-U_NAMESPACE_BEGIN
-
-UBool
-DigitAffixesAndPadding::needsPluralRules() const {
-    return (
-            fPositivePrefix.hasMultipleVariants() ||
-            fPositiveSuffix.hasMultipleVariants() ||
-            fNegativePrefix.hasMultipleVariants() ||
-            fNegativeSuffix.hasMultipleVariants());
-}
-
-UnicodeString &
-DigitAffixesAndPadding::formatInt32(
-        int32_t value,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    if (optPluralRules != NULL || fWidth > 0 || !formatter.isFastFormattable(value)) {
-        VisibleDigitsWithExponent digits;
-        formatter.toVisibleDigitsWithExponent(
-                (int64_t) value, digits, status);
-        return format(
-                digits,
-                formatter,
-                handler,
-                optPluralRules,
-                appendTo,
-                status);
-    }
-    UBool bPositive = value >= 0;
-    const DigitAffix *prefix = bPositive ? &fPositivePrefix.getOtherVariant() : &fNegativePrefix.getOtherVariant();
-    const DigitAffix *suffix = bPositive ? &fPositiveSuffix.getOtherVariant() : &fNegativeSuffix.getOtherVariant();
-    if (value < 0) {
-        value = -value;
-    }
-    prefix->format(handler, appendTo);
-    formatter.formatInt32(value, handler, appendTo);
-    return suffix->format(handler, appendTo);
-}
-
-static UnicodeString &
-formatAffix(
-        const DigitAffix *affix,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) {
-    if (affix) {
-        affix->format(handler, appendTo);
-    }
-    return appendTo;
-}
-
-static int32_t
-countAffixChar32(const DigitAffix *affix) {
-    if (affix) {
-        return affix->countChar32();
-    }
-    return 0;
-}
-
-UnicodeString &
-DigitAffixesAndPadding::format(
-        const VisibleDigitsWithExponent &digits,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    const DigitAffix *prefix = NULL;
-    const DigitAffix *suffix = NULL;
-    if (!digits.isNaN()) {
-        UBool bPositive = !digits.isNegative();
-        const PluralAffix *pluralPrefix = bPositive ? &fPositivePrefix : &fNegativePrefix;
-        const PluralAffix *pluralSuffix = bPositive ? &fPositiveSuffix : &fNegativeSuffix;
-        if (optPluralRules == NULL || digits.isInfinite()) {
-            prefix = &pluralPrefix->getOtherVariant();
-            suffix = &pluralSuffix->getOtherVariant();
-        } else {
-            UnicodeString count(optPluralRules->select(digits));
-            prefix = &pluralPrefix->getByCategory(count);
-            suffix = &pluralSuffix->getByCategory(count);
-        }
-    }
-    if (fWidth <= 0) {
-        formatAffix(prefix, handler, appendTo);
-        formatter.format(digits, handler, appendTo);
-        return formatAffix(suffix, handler, appendTo);
-    }
-    int32_t codePointCount = countAffixChar32(prefix) + formatter.countChar32(digits) + countAffixChar32(suffix);
-    int32_t paddingCount = fWidth - codePointCount;
-    switch (fPadPosition) {
-    case kPadBeforePrefix:
-        appendPadding(paddingCount, appendTo);
-        formatAffix(prefix, handler, appendTo);
-        formatter.format(digits, handler, appendTo);
-        return formatAffix(suffix, handler, appendTo);
-    case kPadAfterPrefix:
-        formatAffix(prefix, handler, appendTo);
-        appendPadding(paddingCount, appendTo);
-        formatter.format(digits, handler, appendTo);
-        return formatAffix(suffix, handler, appendTo);
-    case kPadBeforeSuffix:
-        formatAffix(prefix, handler, appendTo);
-        formatter.format(digits, handler, appendTo);
-        appendPadding(paddingCount, appendTo);
-        return formatAffix(suffix, handler, appendTo);
-    case kPadAfterSuffix:
-        formatAffix(prefix, handler, appendTo);
-        formatter.format(digits, handler, appendTo);
-        formatAffix(suffix, handler, appendTo);
-        return appendPadding(paddingCount, appendTo);
-    default:
-        U_ASSERT(FALSE);
-        return appendTo;
-    }
-}
-
-UnicodeString &
-DigitAffixesAndPadding::format(
-        DigitList &value,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const {
-    VisibleDigitsWithExponent digits;
-    formatter.toVisibleDigitsWithExponent(
-            value, digits, status);
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
-    return format(
-            digits, formatter, handler, optPluralRules, appendTo, status);
-}
-
-UnicodeString &
-DigitAffixesAndPadding::appendPadding(int32_t paddingCount, UnicodeString &appendTo) const {
-    for (int32_t i = 0; i < paddingCount; ++i) {
-        appendTo.append(fPadChar);
-    }
-    return appendTo;
-}
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/digitaffixesandpadding.h b/deps/icu-small/source/i18n/digitaffixesandpadding.h
deleted file mode 100644
index d570599d180e77..00000000000000
--- a/deps/icu-small/source/i18n/digitaffixesandpadding.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* digitaffixesandpadding.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __DIGITAFFIXESANDPADDING_H__
-#define __DIGITAFFIXESANDPADDING_H__
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/uobject.h"
-#include "pluralaffix.h"
-
-U_NAMESPACE_BEGIN
-
-class DigitList;
-class ValueFormatter;
-class UnicodeString;
-class FieldPositionHandler;
-class PluralRules;
-class VisibleDigitsWithExponent;
-
-/**
- * A formatter of numbers. This class can format any numerical value
- * except for not a number (NaN), positive infinity, and negative infinity.
- * This class manages prefixes, suffixes, and padding but delegates the
- * formatting of actual positive values to a ValueFormatter.
- */
-class U_I18N_API DigitAffixesAndPadding : public UMemory {
-public:
-
-/**
- * Equivalent to DecimalFormat EPadPosition, but redeclared here to prevent
- * depending on DecimalFormat which would cause a circular dependency.
- */
-enum EPadPosition {
-    kPadBeforePrefix,
-    kPadAfterPrefix,
-    kPadBeforeSuffix,
-    kPadAfterSuffix
-};
-
-/**
- * The positive prefix
- */
-PluralAffix fPositivePrefix;
-
-/**
- * The positive suffix
- */
-PluralAffix fPositiveSuffix;
-
-/**
- * The negative suffix
- */
-PluralAffix fNegativePrefix;
-
-/**
- * The negative suffix
- */
-PluralAffix fNegativeSuffix;
-
-/**
- * The padding position
- */
-EPadPosition fPadPosition;
-
-/**
- * The padding character.
- */
-UChar32 fPadChar;
-
-/**
- * The field width in code points. The format method inserts instances of
- * the padding character as needed in the desired padding position so that
- * the entire formatted string contains this many code points. If the
- * formatted string already exceeds this many code points, the format method
- * inserts no padding.
- */
-int32_t fWidth;
-
-/**
- * Pad position is before prefix; padding character is '*' field width is 0.
- * The affixes are all the empty string with no annotated fields with just
- * the 'other' plural variation.
- */
-DigitAffixesAndPadding()
-        : fPadPosition(kPadBeforePrefix), fPadChar(0x2a), fWidth(0) { }
-
-/**
- * Returns TRUE if this object is equal to rhs.
- */
-UBool equals(const DigitAffixesAndPadding &rhs) const {
-    return (fPositivePrefix.equals(rhs.fPositivePrefix) &&
-            fPositiveSuffix.equals(rhs.fPositiveSuffix) &&
-            fNegativePrefix.equals(rhs.fNegativePrefix) &&
-            fNegativeSuffix.equals(rhs.fNegativeSuffix) &&
-            fPadPosition == rhs.fPadPosition &&
-            fWidth == rhs.fWidth &&
-            fPadChar == rhs.fPadChar);
-}
-
-/**
- * Returns TRUE if a plural rules instance is needed to complete the
- * formatting by detecting if any of the affixes have multiple plural
- * variations.
- */
-UBool needsPluralRules() const;
-
-/**
- * Formats value and appends to appendTo.
- *
- * @param value the value to format. May be NaN or ininite.
- * @param formatter handles the details of formatting the actual value.
- * @param handler records field positions
- * @param optPluralRules the plural rules, but may be NULL if
- *   needsPluralRules returns FALSE.
- * @appendTo formatted string appended here.
- * @status any error returned here.
- */
-UnicodeString &format(
-        const VisibleDigitsWithExponent &value,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const;
-
-/**
- * For testing only.
- */
-UnicodeString &format(
-        DigitList &value,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const;
-
-/**
- * Formats a 32-bit integer and appends to appendTo. When formatting an
- * integer, this method is preferred to plain format as it can run
- * several times faster under certain conditions.
- *
- * @param value the value to format.
- * @param formatter handles the details of formatting the actual value.
- * @param handler records field positions
- * @param optPluralRules the plural rules, but may be NULL if
- *   needsPluralRules returns FALSE.
- * @appendTo formatted string appended here.
- * @status any error returned here.
- */
-UnicodeString &formatInt32(
-        int32_t value,
-        const ValueFormatter &formatter,
-        FieldPositionHandler &handler,
-        const PluralRules *optPluralRules,
-        UnicodeString &appendTo,
-        UErrorCode &status) const;
-
-private:
-UnicodeString &appendPadding(int32_t paddingCount, UnicodeString &appendTo) const;
-
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif  // __DIGITAFFIXANDPADDING_H__
diff --git a/deps/icu-small/source/i18n/digitformatter.cpp b/deps/icu-small/source/i18n/digitformatter.cpp
deleted file mode 100644
index 0d857f8f6873c6..00000000000000
--- a/deps/icu-small/source/i18n/digitformatter.cpp
+++ /dev/null
@@ -1,417 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: digitformatter.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/dcfmtsym.h"
-#include "unicode/unum.h"
-
-#include "digitformatter.h"
-#include "digitgrouping.h"
-#include "digitinterval.h"
-#include "digitlst.h"
-#include "fphdlimp.h"
-#include "smallintformatter.h"
-#include "unistrappender.h"
-#include "visibledigits.h"
-
-U_NAMESPACE_BEGIN
-
-DigitFormatter::DigitFormatter()
-        : fGroupingSeparator(",", -1, US_INV), fDecimal(".", -1, US_INV),
-          fNegativeSign("-", -1, US_INV), fPositiveSign("+", -1, US_INV),
-          fIsStandardDigits(TRUE), fExponent("E", -1, US_INV) {
-    for (int32_t i = 0; i < 10; ++i) {
-        fLocalizedDigits[i] = (UChar32) (0x30 + i);
-    }
-    fInfinity.setTo(UnicodeString("Inf", -1, US_INV), UNUM_INTEGER_FIELD);
-    fNan.setTo(UnicodeString("Nan", -1, US_INV), UNUM_INTEGER_FIELD);
-}
-
-DigitFormatter::DigitFormatter(const DecimalFormatSymbols &symbols) {
-    setDecimalFormatSymbols(symbols);
-}
-
-void
-DigitFormatter::setOtherDecimalFormatSymbols(
-        const DecimalFormatSymbols &symbols) {
-    fLocalizedDigits[0] = symbols.getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol).char32At(0);
-    fLocalizedDigits[1] = symbols.getConstSymbol(DecimalFormatSymbols::kOneDigitSymbol).char32At(0);
-    fLocalizedDigits[2] = symbols.getConstSymbol(DecimalFormatSymbols::kTwoDigitSymbol).char32At(0);
-    fLocalizedDigits[3] = symbols.getConstSymbol(DecimalFormatSymbols::kThreeDigitSymbol).char32At(0);
-    fLocalizedDigits[4] = symbols.getConstSymbol(DecimalFormatSymbols::kFourDigitSymbol).char32At(0);
-    fLocalizedDigits[5] = symbols.getConstSymbol(DecimalFormatSymbols::kFiveDigitSymbol).char32At(0);
-    fLocalizedDigits[6] = symbols.getConstSymbol(DecimalFormatSymbols::kSixDigitSymbol).char32At(0);
-    fLocalizedDigits[7] = symbols.getConstSymbol(DecimalFormatSymbols::kSevenDigitSymbol).char32At(0);
-    fLocalizedDigits[8] = symbols.getConstSymbol(DecimalFormatSymbols::kEightDigitSymbol).char32At(0);
-    fLocalizedDigits[9] = symbols.getConstSymbol(DecimalFormatSymbols::kNineDigitSymbol).char32At(0);
-    fIsStandardDigits = isStandardDigits();
-    fNegativeSign = symbols.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
-    fPositiveSign = symbols.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
-    fInfinity.setTo(symbols.getConstSymbol(DecimalFormatSymbols::kInfinitySymbol), UNUM_INTEGER_FIELD);
-    fNan.setTo(symbols.getConstSymbol(DecimalFormatSymbols::kNaNSymbol), UNUM_INTEGER_FIELD);
-    fExponent = symbols.getConstSymbol(DecimalFormatSymbols::kExponentialSymbol);
-}
-
-void
-DigitFormatter::setDecimalFormatSymbolsForMonetary(
-        const DecimalFormatSymbols &symbols) {
-    setOtherDecimalFormatSymbols(symbols);
-    fGroupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol);
-    fDecimal = symbols.getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol);
-}
-
-void
-DigitFormatter::setDecimalFormatSymbols(
-        const DecimalFormatSymbols &symbols) {
-    setOtherDecimalFormatSymbols(symbols);
-    fGroupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
-    fDecimal = symbols.getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
-}
-
-static void appendField(
-        int32_t fieldId,
-        const UnicodeString &value,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) {
-    int32_t currentLength = appendTo.length();
-    appendTo.append(value);
-    handler.addAttribute(
-            fieldId,
-            currentLength,
-            appendTo.length());
-}
-
-int32_t DigitFormatter::countChar32(
-        const DigitGrouping &grouping,
-        const DigitInterval &interval,
-        const DigitFormatterOptions &options) const {
-    int32_t result = interval.length();
-
-    // We always emit '0' in lieu of no digits.
-    if (result == 0) {
-        result = 1;
-    }
-    if (options.fAlwaysShowDecimal || interval.getLeastSignificantInclusive() < 0) {
-        result += fDecimal.countChar32();
-    }
-    result += grouping.getSeparatorCount(interval.getIntDigitCount()) * fGroupingSeparator.countChar32();
-    return result;
-}
-
-int32_t
-DigitFormatter::countChar32(
-        const VisibleDigits &digits,
-        const DigitGrouping &grouping,
-        const DigitFormatterOptions &options) const {
-    if (digits.isNaN()) {
-        return countChar32ForNaN();
-    }
-    if (digits.isInfinite()) {
-        return countChar32ForInfinity();
-    }
-    return countChar32(
-            grouping,
-            digits.getInterval(),
-            options);
-}
-
-int32_t
-DigitFormatter::countChar32(
-        const VisibleDigitsWithExponent &digits,
-        const SciFormatterOptions &options) const {
-    if (digits.isNaN()) {
-        return countChar32ForNaN();
-    }
-    if (digits.isInfinite()) {
-        return countChar32ForInfinity();
-    }
-    const VisibleDigits *exponent = digits.getExponent();
-    if (exponent == NULL) {
-        DigitGrouping grouping;
-        return countChar32(
-                grouping,
-                digits.getMantissa().getInterval(),
-                options.fMantissa);
-    }
-    return countChar32(
-            *exponent, digits.getMantissa().getInterval(), options);
-}
-
-int32_t
-DigitFormatter::countChar32(
-        const VisibleDigits &exponent,
-        const DigitInterval &mantissaInterval,
-        const SciFormatterOptions &options) const {
-    DigitGrouping grouping;
-    int32_t count = countChar32(
-            grouping, mantissaInterval, options.fMantissa);
-    count += fExponent.countChar32();
-    count += countChar32ForExponent(
-            exponent, options.fExponent);
-    return count;
-}
-
-UnicodeString &DigitFormatter::format(
-        const VisibleDigits &digits,
-        const DigitGrouping &grouping,
-        const DigitFormatterOptions &options,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    if (digits.isNaN()) {
-        return formatNaN(handler, appendTo);
-    }
-    if (digits.isInfinite()) {
-        return formatInfinity(handler, appendTo);
-    }
-
-    const DigitInterval &interval = digits.getInterval();
-    int32_t digitsLeftOfDecimal = interval.getMostSignificantExclusive();
-    int32_t lastDigitPos = interval.getLeastSignificantInclusive();
-    int32_t intBegin = appendTo.length();
-    int32_t fracBegin = 0; /* initialize to avoid compiler warning */
-
-    // Emit "0" instead of empty string.
-    if (digitsLeftOfDecimal == 0 && lastDigitPos == 0) {
-        appendTo.append(fLocalizedDigits[0]);
-        handler.addAttribute(UNUM_INTEGER_FIELD, intBegin, appendTo.length());
-        if (options.fAlwaysShowDecimal) {
-            appendField(
-                    UNUM_DECIMAL_SEPARATOR_FIELD,
-                    fDecimal,
-                    handler,
-                    appendTo);
-        }
-        return appendTo;
-    }
-    {
-        UnicodeStringAppender appender(appendTo);
-        for (int32_t i = interval.getMostSignificantExclusive() - 1;
-                i >= interval.getLeastSignificantInclusive(); --i) {
-            if (i == -1) {
-                appender.flush();
-                appendField(
-                        UNUM_DECIMAL_SEPARATOR_FIELD,
-                        fDecimal,
-                        handler,
-                        appendTo);
-                fracBegin = appendTo.length();
-            }
-            appender.append(fLocalizedDigits[digits.getDigitByExponent(i)]);
-            if (grouping.isSeparatorAt(digitsLeftOfDecimal, i)) {
-                appender.flush();
-                appendField(
-                        UNUM_GROUPING_SEPARATOR_FIELD,
-                        fGroupingSeparator,
-                        handler,
-                        appendTo);
-            }
-            if (i == 0) {
-                appender.flush();
-                if (digitsLeftOfDecimal > 0) {
-                    handler.addAttribute(UNUM_INTEGER_FIELD, intBegin, appendTo.length());
-                }
-            }
-        }
-        if (options.fAlwaysShowDecimal && lastDigitPos == 0) {
-            appender.flush();
-            appendField(
-                    UNUM_DECIMAL_SEPARATOR_FIELD,
-                    fDecimal,
-                    handler,
-                    appendTo);
-        }
-    }
-    // lastDigitPos is never > 0 so we are guaranteed that kIntegerField
-    // is already added.
-    if (lastDigitPos < 0) {
-        handler.addAttribute(UNUM_FRACTION_FIELD, fracBegin, appendTo.length());
-    }
-    return appendTo;
-}
-
-UnicodeString &
-DigitFormatter::format(
-        const VisibleDigitsWithExponent &digits,
-        const SciFormatterOptions &options,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    DigitGrouping grouping;
-    format(
-            digits.getMantissa(),
-            grouping,
-            options.fMantissa,
-            handler,
-            appendTo);
-    const VisibleDigits *exponent = digits.getExponent();
-    if (exponent == NULL) {
-        return appendTo;
-    }
-    int32_t expBegin = appendTo.length();
-    appendTo.append(fExponent);
-    handler.addAttribute(
-            UNUM_EXPONENT_SYMBOL_FIELD, expBegin, appendTo.length());
-    return formatExponent(
-            *exponent,
-            options.fExponent,
-            UNUM_EXPONENT_SIGN_FIELD,
-            UNUM_EXPONENT_FIELD,
-            handler,
-            appendTo);
-}
-
-static int32_t formatInt(
-        int32_t value, uint8_t *digits) {
-    int32_t idx = 0;
-    while (value > 0) {
-        digits[idx++] = (uint8_t) (value % 10);
-        value /= 10;
-    }
-    return idx;
-}
-
-UnicodeString &
-DigitFormatter::formatDigits(
-        const uint8_t *digits,
-        int32_t count,
-        const IntDigitCountRange &range,
-        int32_t intField,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    int32_t i = range.pin(count) - 1;
-    int32_t begin = appendTo.length();
-
-    // Always emit '0' as placeholder for empty string.
-    if (i == -1) {
-        appendTo.append(fLocalizedDigits[0]);
-        handler.addAttribute(intField, begin, appendTo.length());
-        return appendTo;
-    }
-    {
-        UnicodeStringAppender appender(appendTo);
-        for (; i >= count; --i) {
-            appender.append(fLocalizedDigits[0]);
-        }
-        for (; i >= 0; --i) {
-            appender.append(fLocalizedDigits[digits[i]]);
-        }
-    }
-    handler.addAttribute(intField, begin, appendTo.length());
-    return appendTo;
-}
-
-UnicodeString &
-DigitFormatter::formatExponent(
-        const VisibleDigits &digits,
-        const DigitFormatterIntOptions &options,
-        int32_t signField,
-        int32_t intField,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    UBool neg = digits.isNegative();
-    if (neg || options.fAlwaysShowSign) {
-        appendField(
-                signField,
-                neg ? fNegativeSign : fPositiveSign,
-                handler,
-                appendTo);
-    }
-    int32_t begin = appendTo.length();
-    DigitGrouping grouping;
-    DigitFormatterOptions expOptions;
-    FieldPosition fpos(FieldPosition::DONT_CARE);
-    FieldPositionOnlyHandler noHandler(fpos);
-    format(
-            digits,
-            grouping,
-            expOptions,
-            noHandler,
-            appendTo);
-    handler.addAttribute(intField, begin, appendTo.length());
-    return appendTo;
-}
-
-int32_t
-DigitFormatter::countChar32ForExponent(
-        const VisibleDigits &exponent,
-        const DigitFormatterIntOptions &options) const {
-    int32_t result = 0;
-    UBool neg = exponent.isNegative();
-    if (neg || options.fAlwaysShowSign) {
-        result += neg ? fNegativeSign.countChar32() : fPositiveSign.countChar32();
-    }
-    DigitGrouping grouping;
-    DigitFormatterOptions expOptions;
-    result += countChar32(grouping, exponent.getInterval(), expOptions);
-    return result;
-}
-
-UnicodeString &
-DigitFormatter::formatPositiveInt32(
-        int32_t positiveValue,
-        const IntDigitCountRange &range,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    // super fast path
-    if (fIsStandardDigits && SmallIntFormatter::canFormat(positiveValue, range)) {
-        int32_t begin = appendTo.length();
-        SmallIntFormatter::format(positiveValue, range, appendTo);
-        handler.addAttribute(UNUM_INTEGER_FIELD, begin, appendTo.length());
-        return appendTo;
-    }
-    uint8_t digits[10];
-    int32_t count = formatInt(positiveValue, digits);
-    return formatDigits(
-            digits,
-            count,
-            range,
-            UNUM_INTEGER_FIELD,
-            handler,
-            appendTo);
-}
-
-UBool DigitFormatter::isStandardDigits() const {
-    UChar32 cdigit = 0x30;
-    for (int32_t i = 0; i < UPRV_LENGTHOF(fLocalizedDigits); ++i) {
-        if (fLocalizedDigits[i] != cdigit) {
-            return FALSE;
-        }
-        ++cdigit;
-    }
-    return TRUE;
-}
-
-UBool
-DigitFormatter::equals(const DigitFormatter &rhs) const {
-    UBool result = (fGroupingSeparator == rhs.fGroupingSeparator) &&
-                   (fDecimal == rhs.fDecimal) &&
-                   (fNegativeSign == rhs.fNegativeSign) &&
-                   (fPositiveSign == rhs.fPositiveSign) &&
-                   (fInfinity.equals(rhs.fInfinity)) &&
-                   (fNan.equals(rhs.fNan)) &&
-                   (fIsStandardDigits == rhs.fIsStandardDigits) &&
-                   (fExponent == rhs.fExponent);
-
-    if (!result) {
-        return FALSE;
-    }
-    for (int32_t i = 0; i < UPRV_LENGTHOF(fLocalizedDigits); ++i) {
-        if (fLocalizedDigits[i] != rhs.fLocalizedDigits[i]) {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/digitformatter.h b/deps/icu-small/source/i18n/digitformatter.h
deleted file mode 100644
index 54a54c3639a629..00000000000000
--- a/deps/icu-small/source/i18n/digitformatter.h
+++ /dev/null
@@ -1,288 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* digitformatter.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __DIGITFORMATTER_H__
-#define __DIGITFORMATTER_H__
-
-#include "unicode/uobject.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/utypes.h"
-#include "unicode/unistr.h"
-#include "digitaffix.h"
-
-U_NAMESPACE_BEGIN
-
-class DecimalFormatSymbols;
-class DigitList;
-class DigitGrouping;
-class DigitInterval;
-class UnicodeString;
-class FieldPositionHandler;
-class IntDigitCountRange;
-class VisibleDigits;
-class VisibleDigitsWithExponent;
-
-/**
- * Various options for formatting in fixed point.
- */
-class U_I18N_API DigitFormatterOptions : public UMemory {
-    public:
-    DigitFormatterOptions() : fAlwaysShowDecimal(FALSE) { }
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const DigitFormatterOptions &rhs) const {
-        return (
-            fAlwaysShowDecimal == rhs.fAlwaysShowDecimal);
-    }
-
-    /**
-     * Returns TRUE if these options allow for fast formatting of
-     * integers.
-     */
-    UBool isFastFormattable() const {
-        return (fAlwaysShowDecimal == FALSE);
-    }
-
-    /**
-     * If TRUE, show the decimal separator even when there are no fraction
-     * digits. default is FALSE.
-     */
-    UBool fAlwaysShowDecimal;
-};
-
-/**
- * Various options for formatting an integer.
- */
-class U_I18N_API DigitFormatterIntOptions : public UMemory {
-    public:
-    DigitFormatterIntOptions() : fAlwaysShowSign(FALSE) { }
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const DigitFormatterIntOptions &rhs) const {
-        return (fAlwaysShowSign == rhs.fAlwaysShowSign);
-    }
-
-    /**
-     * If TRUE, always prefix the integer with its sign even if the number is
-     * positive. Default is FALSE.
-     */
-    UBool fAlwaysShowSign;
-};
-
-/**
- * Options for formatting in scientific notation.
- */
-class U_I18N_API SciFormatterOptions : public UMemory {
-    public:
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const SciFormatterOptions &rhs) const {
-        return (fMantissa.equals(rhs.fMantissa) &&
-                fExponent.equals(rhs.fExponent));
-    }
-
-    /**
-     * Options for formatting the mantissa.
-     */
-    DigitFormatterOptions fMantissa;
-
-    /**
-     * Options for formatting the exponent.
-     */
-    DigitFormatterIntOptions fExponent;
-};
-
-
-/**
- * Does fixed point formatting.
- *
- * This class only does fixed point formatting. It does no rounding before
- * formatting.
- */
-class U_I18N_API DigitFormatter : public UMemory {
-public:
-
-/**
- * Decimal separator is period (.), Plus sign is plus (+),
- * minus sign is minus (-), grouping separator is comma (,), digits are 0-9.
- */
-DigitFormatter();
-
-/**
- * Let symbols determine the digits, decimal separator,
- * plus and mius sign, grouping separator, and possibly other settings.
- */
-DigitFormatter(const DecimalFormatSymbols &symbols);
-
-/**
- * Change what this instance uses for digits, decimal separator,
- * plus and mius sign, grouping separator, and possibly other settings
- * according to symbols.
- */
-void setDecimalFormatSymbols(const DecimalFormatSymbols &symbols);
-
-/**
- * Change what this instance uses for digits, decimal separator,
- * plus and mius sign, grouping separator, and possibly other settings
- * according to symbols in the context of monetary amounts.
- */
-void setDecimalFormatSymbolsForMonetary(const DecimalFormatSymbols &symbols);
-
-/**
- * Fixed point formatting.
- *
- * @param positiveDigits the value to format
- *  Negative sign can be present, but it won't show.
- * @param grouping controls how digit grouping is done
- * @param options formatting options
- * @param handler records field positions
- * @param appendTo formatted value appended here.
- * @return appendTo
- */
-UnicodeString &format(
-        const VisibleDigits &positiveDigits,
-        const DigitGrouping &grouping,
-        const DigitFormatterOptions &options,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-/**
- * formats in scientifc notation.
- * @param positiveDigits the value to format.
- *  Negative sign can be present, but it won't show.
- * @param options formatting options
- * @param handler records field positions.
- * @param appendTo formatted value appended here.
- */
-UnicodeString &format(
-        const VisibleDigitsWithExponent &positiveDigits,
-        const SciFormatterOptions &options,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-/**
- * Fixed point formatting of integers.
- * Always performed with no grouping and no decimal point.
- *
- * @param positiveValue the value to format must be positive.
- * @param range specifies minimum and maximum number of digits.
- * @param handler records field positions
- * @param appendTo formatted value appended here.
- * @return appendTo
- */
-UnicodeString &formatPositiveInt32(
-        int32_t positiveValue,
-        const IntDigitCountRange &range,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-/**
- * Counts how many code points are needed for fixed formatting.
- *   If digits is negative, the negative sign is not included in the count.
- */
-int32_t countChar32(
-        const VisibleDigits &digits,
-        const DigitGrouping &grouping,
-        const DigitFormatterOptions &options) const;
-
-/**
- * Counts how many code points are needed for scientific formatting.
- *   If digits is negative, the negative sign is not included in the count.
- */
-int32_t countChar32(
-        const VisibleDigitsWithExponent &digits,
-        const SciFormatterOptions &options) const;
-
-/**
- * Returns TRUE if this object equals rhs.
- */
-UBool equals(const DigitFormatter &rhs) const;
-
-private:
-UChar32 fLocalizedDigits[10];
-UnicodeString fGroupingSeparator;
-UnicodeString fDecimal;
-UnicodeString fNegativeSign;
-UnicodeString fPositiveSign;
-DigitAffix fInfinity;
-DigitAffix fNan;
-UBool fIsStandardDigits;
-UnicodeString fExponent;
-UBool isStandardDigits() const;
-
-UnicodeString &formatDigits(
-        const uint8_t *digits,
-        int32_t count,
-        const IntDigitCountRange &range,
-        int32_t intField,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-void setOtherDecimalFormatSymbols(const DecimalFormatSymbols &symbols);
-
-int32_t countChar32(
-        const VisibleDigits &exponent,
-        const DigitInterval &mantissaInterval,
-        const SciFormatterOptions &options) const;
-
-UnicodeString &formatNaN(
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    return fNan.format(handler, appendTo);
-}
-
-int32_t countChar32ForNaN() const {
-    return fNan.toString().countChar32();
-}
-
-UnicodeString &formatInfinity(
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    return fInfinity.format(handler, appendTo);
-}
-
-int32_t countChar32ForInfinity() const {
-    return fInfinity.toString().countChar32();
-}
-
-UnicodeString &formatExponent(
-        const VisibleDigits &digits,
-        const DigitFormatterIntOptions &options,
-        int32_t signField,
-        int32_t intField,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-int32_t countChar32(
-        const DigitGrouping &grouping,
-        const DigitInterval &interval,
-        const DigitFormatterOptions &options) const;
-
-int32_t countChar32ForExponent(
-        const VisibleDigits &exponent,
-        const DigitFormatterIntOptions &options) const;
-
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif  // __DIGITFORMATTER_H__
diff --git a/deps/icu-small/source/i18n/digitgrouping.cpp b/deps/icu-small/source/i18n/digitgrouping.cpp
deleted file mode 100644
index cffa122b6ceaf6..00000000000000
--- a/deps/icu-small/source/i18n/digitgrouping.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: digitgrouping.cpp
- */
-
-#include "unicode/utypes.h"
-
-#include "digitgrouping.h"
-#include "smallintformatter.h"
-
-U_NAMESPACE_BEGIN
-
-UBool DigitGrouping::isSeparatorAt(
-        int32_t digitsLeftOfDecimal, int32_t digitPos) const {
-    if (!isGroupingEnabled(digitsLeftOfDecimal) || digitPos < fGrouping) {
-        return FALSE;
-    }
-    return ((digitPos - fGrouping) % getGrouping2() == 0);
-}
-
-int32_t DigitGrouping::getSeparatorCount(int32_t digitsLeftOfDecimal) const {
-    if (!isGroupingEnabled(digitsLeftOfDecimal)) {
-        return 0;
-    }
-    return (digitsLeftOfDecimal - 1 - fGrouping) / getGrouping2() + 1;
-}
-
-UBool DigitGrouping::isGroupingEnabled(int32_t digitsLeftOfDecimal) const {
-    return (isGroupingUsed()
-            && digitsLeftOfDecimal >= fGrouping + getMinGrouping());
-}
-
-UBool DigitGrouping::isNoGrouping(
-        int32_t positiveValue, const IntDigitCountRange &range) const {
-    return getSeparatorCount(
-            SmallIntFormatter::estimateDigitCount(positiveValue, range)) == 0;
-}
-
-int32_t DigitGrouping::getGrouping2() const {
-    return (fGrouping2 > 0 ? fGrouping2 : fGrouping);
-}
-
-int32_t DigitGrouping::getMinGrouping() const {
-    return (fMinGrouping > 0 ? fMinGrouping : 1);
-}
-
-void
-DigitGrouping::clear() {
-    fMinGrouping = 0;
-    fGrouping = 0;
-    fGrouping2 = 0;
-}
-
-U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/digitgrouping.h b/deps/icu-small/source/i18n/digitgrouping.h
deleted file mode 100644
index f3f8679b879e95..00000000000000
--- a/deps/icu-small/source/i18n/digitgrouping.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* digitgrouping.h
-*
-* created on: 2015jan6
-* created by: Travis Keep
-*/
-
-#ifndef __DIGITGROUPING_H__
-#define __DIGITGROUPING_H__
-
-#include "unicode/uobject.h"
-#include "unicode/utypes.h"
-
-U_NAMESPACE_BEGIN
-
-class IntDigitCountRange;
-
-/**
- * The digit grouping policy.
- */
-class U_I18N_API DigitGrouping : public UMemory {
-public:
-    /**
-     * Default is no digit grouping.
-     */
-    DigitGrouping() : fGrouping(0), fGrouping2(0), fMinGrouping(0) { }
-
-    /**
-     * Returns TRUE if this object is equal to rhs.
-     */
-    UBool equals(const DigitGrouping &rhs) const {
-        return ((fGrouping == rhs.fGrouping) &&
-                (fGrouping2 == rhs.fGrouping2) &&
-                (fMinGrouping == rhs.fMinGrouping));
-    }
-
-    /**
-     * Returns true if a separator is needed after a particular digit.
-     * @param digitsLeftOfDecimal the total count of digits left of the
-     *  decimal.
-     * @param digitPos 0 is the one's place; 1 is the 10's place; -1 is the
-     *   1/10's place etc.
-     */
-    UBool isSeparatorAt(int32_t digitsLeftOfDecimal, int32_t digitPos) const;
-
-    /**
-     * Returns the total number of separators to be used to format a particular
-     * number.
-     * @param digitsLeftOfDecimal the total number of digits to the left of
-     *   the decimal.
-     */
-    int32_t getSeparatorCount(int32_t digitsLeftOfDecimal) const;
-
-    /**
-     * Returns true if grouping is used FALSE otherwise. When
-     * isGroupingUsed() returns FALSE; isSeparatorAt always returns FALSE
-     * and getSeparatorCount always returns 0.
-     */
-    UBool isGroupingUsed() const { return fGrouping > 0; }
-
-    /**
-     * Returns TRUE if this instance would not add grouping separators
-     * when formatting value using the given constraint on digit count.
-     *
-     * @param value the value to format.
-     * @param range the minimum and maximum digits for formatting value.
-     */
-    UBool isNoGrouping(
-            int32_t positiveValue, const IntDigitCountRange &range) const;
-
-    /**
-     * Clears this instance so that digit grouping is not in effect.
-     */
-    void clear();
-
-public:
-
-    /**
-     * Primary grouping size. A value of 0, the default, or a negative
-     * number causes isGroupingUsed() to return FALSE.
-     */
-    int32_t fGrouping;
-
-    /**
-     * Secondary grouping size. If > 0, this size is used instead of
-     * 'fGrouping' for all but the group just to the left of the decimal
-     * point. The default value of 0, or a negative value indicates that
-     * there is no secondary grouping size.
-     */
-    int32_t fGrouping2;
-
-    /**
-     * If set (that is > 0), uses no grouping separators if fewer than
-     * (fGrouping + fMinGrouping) digits appear left of the decimal place.
-     * The default value for this field is 0.
-     */
-    int32_t fMinGrouping;
-private:
-    UBool isGroupingEnabled(int32_t digitsLeftOfDecimal) const;
-    int32_t getGrouping2() const;
-    int32_t getMinGrouping() const;
-};
-
-U_NAMESPACE_END
-
-#endif  // __DIGITGROUPING_H__
diff --git a/deps/icu-small/source/i18n/digitinterval.cpp b/deps/icu-small/source/i18n/digitinterval.cpp
deleted file mode 100644
index 32d952e0267950..00000000000000
--- a/deps/icu-small/source/i18n/digitinterval.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: digitinterval.cpp
- */
-
-#include "unicode/utypes.h"
-
-#include "digitinterval.h"
-
-U_NAMESPACE_BEGIN
-
-void DigitInterval::expandToContain(const DigitInterval &rhs) {
-    if (fSmallestInclusive > rhs.fSmallestInclusive) {
-        fSmallestInclusive = rhs.fSmallestInclusive;
-    }
-    if (fLargestExclusive < rhs.fLargestExclusive) {
-        fLargestExclusive = rhs.fLargestExclusive;
-    }
-}
-
-void DigitInterval::shrinkToFitWithin(const DigitInterval &rhs) {
-    if (fSmallestInclusive < rhs.fSmallestInclusive) {
-        fSmallestInclusive = rhs.fSmallestInclusive;
-    }
-    if (fLargestExclusive > rhs.fLargestExclusive) {
-        fLargestExclusive = rhs.fLargestExclusive;
-    }
-}
-
-void DigitInterval::setIntDigitCount(int32_t count) {
-    fLargestExclusive = count < 0 ? INT32_MAX : count;
-}
-
-void DigitInterval::setFracDigitCount(int32_t count) {
-    fSmallestInclusive = count < 0 ? INT32_MIN : -count;
-}
-
-void DigitInterval::expandToContainDigit(int32_t digitExponent) {
-  if (fLargestExclusive <= digitExponent) {
-      fLargestExclusive = digitExponent + 1;
-  } else if (fSmallestInclusive > digitExponent) {
-      fSmallestInclusive = digitExponent;
-  }
-}
-
-UBool DigitInterval::contains(int32_t x) const {
-    return (x < fLargestExclusive && x >= fSmallestInclusive);
-}
-
-
-U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/digitinterval.h b/deps/icu-small/source/i18n/digitinterval.h
deleted file mode 100644
index 95d406da206f4c..00000000000000
--- a/deps/icu-small/source/i18n/digitinterval.h
+++ /dev/null
@@ -1,159 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* digitinterval.h
-*
-* created on: 2015jan6
-* created by: Travis Keep
-*/
-
-#ifndef __DIGITINTERVAL_H__
-#define __DIGITINTERVAL_H__
-
-#include "unicode/uobject.h"
-#include "unicode/utypes.h"
-
-U_NAMESPACE_BEGIN
-
-/**
- * An interval of digits.
- * DigitIntervals are for fixed point formatting. A DigitInterval specifies
- * zero or more integer digits and zero or more fractional digits. This class
- * specifies particular digits in a number by their power of 10. For example,
- * the digit position just to the left of the decimal is 0, and the digit
- * position just left of that is 1. The digit position just to the right of
- * the decimal is -1. The digit position just to the right of that is -2.
- */
-class U_I18N_API DigitInterval : public UMemory {
-public:
-
-    /**
-     * Spans all integer and fraction digits
-     */
-    DigitInterval()
-            : fLargestExclusive(INT32_MAX), fSmallestInclusive(INT32_MIN) { }
-
-
-    /**
-     * Makes this instance span all digits.
-     */
-    void clear() {
-        fLargestExclusive = INT32_MAX;
-        fSmallestInclusive = INT32_MIN;
-    }
-
-    /**
-     * Returns TRUE if this interval contains this digit position.
-     */
-    UBool contains(int32_t digitPosition) const;
-
-    /**
-     * Returns true if this object is the same as rhs.
-     */
-    UBool equals(const DigitInterval &rhs) const {
-        return ((fLargestExclusive == rhs.fLargestExclusive) &&
-                (fSmallestInclusive == rhs.fSmallestInclusive));
-    }
-
-    /**
-     * Expand this interval so that it contains all of rhs.
-     */
-    void expandToContain(const DigitInterval &rhs);
-
-    /**
-     * Shrink this interval so that it contains no more than rhs.
-     */
-    void shrinkToFitWithin(const DigitInterval &rhs);
-
-    /**
-     * Expand this interval as necessary to contain digit with given exponent
-     * After this method returns, this interval is guaranteed to contain
-     * digitExponent.
-     */
-    void expandToContainDigit(int32_t digitExponent);
-
-    /**
-     * Changes the number of digits to the left of the decimal point that
-     * this interval spans. If count is negative, it means span all digits
-     * to the left of the decimal point.
-     */
-    void setIntDigitCount(int32_t count);
-
-    /**
-     * Changes the number of digits to the right of the decimal point that
-     * this interval spans. If count is negative, it means span all digits
-     * to the right of the decimal point.
-     */
-    void setFracDigitCount(int32_t count);
-
-    /**
-     * Sets the least significant inclusive value to smallest. If smallest >= 0
-     * then least significant inclusive value becomes 0.
-     */
-    void setLeastSignificantInclusive(int32_t smallest) {
-        fSmallestInclusive = smallest < 0 ? smallest : 0;
-    }
-
-    /**
-     * Sets the most significant exclusive value to largest.
-     * If largest <= 0 then most significant exclusive value becomes 0.
-     */
-    void setMostSignificantExclusive(int32_t largest) {
-        fLargestExclusive = largest > 0 ? largest : 0;
-    }
-
-    /**
-     * If returns 8, the most significant digit in interval is the 10^7 digit.
-     * Returns INT32_MAX if this interval spans all digits to left of
-     * decimal point.
-     */
-    int32_t getMostSignificantExclusive() const {
-        return fLargestExclusive;
-    }
-
-    /**
-     * Returns number of digits to the left of the decimal that this
-     * interval includes. This is a synonym for getMostSignificantExclusive().
-     */
-    int32_t getIntDigitCount() const {
-        return fLargestExclusive;
-    }
-
-    /**
-     * Returns number of digits to the right of the decimal that this
-     * interval includes.
-     */
-    int32_t getFracDigitCount() const {
-        return fSmallestInclusive == INT32_MIN ? INT32_MAX : -fSmallestInclusive;
-    }
-
-    /**
-     * Returns the total number of digits that this interval spans.
-     * Caution: If this interval spans all digits to the left or right of
-     * decimal point instead of some fixed number, then what length()
-     * returns is undefined.
-     */
-    int32_t length() const {
-        return fLargestExclusive - fSmallestInclusive;
-     }
-
-    /**
-     * If returns -3, the least significant digit in interval is the 10^-3
-     * digit. Returns INT32_MIN if this interval spans all digits to right of
-     * decimal point.
-     */
-    int32_t getLeastSignificantInclusive() const {
-        return fSmallestInclusive;
-    }
-private:
-    int32_t fLargestExclusive;
-    int32_t fSmallestInclusive;
-};
-
-U_NAMESPACE_END
-
-#endif  // __DIGITINTERVAL_H__
diff --git a/deps/icu-small/source/i18n/digitlst.cpp b/deps/icu-small/source/i18n/digitlst.cpp
deleted file mode 100644
index 37760defd708bc..00000000000000
--- a/deps/icu-small/source/i18n/digitlst.cpp
+++ /dev/null
@@ -1,1143 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-**********************************************************************
-*   Copyright (C) 1997-2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-**********************************************************************
-*
-* File DIGITLST.CPP
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   03/21/97    clhuang     Converted from java.
-*   03/21/97    clhuang     Implemented with new APIs.
-*   03/27/97    helena      Updated to pass the simple test after code review.
-*   03/31/97    aliu        Moved isLONG_MIN to here, and fixed it.
-*   04/15/97    aliu        Changed MAX_COUNT to DBL_DIG.  Changed Digit to char.
-*                           Reworked representation by replacing fDecimalAt
-*                           with fExponent.
-*   04/16/97    aliu        Rewrote set() and getDouble() to use sprintf/atof
-*                           to do digit conversion.
-*   09/09/97    aliu        Modified for exponential notation support.
-*   08/02/98    stephen     Added nearest/even rounding
-*                            Fixed bug in fitsIntoLong
-******************************************************************************
-*/
-
-#if defined(__CYGWIN__) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-
-#include "digitlst.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/putil.h"
-#include "charstr.h"
-#include "cmemory.h"
-#include "cstring.h"
-#include "mutex.h"
-#include "putilimp.h"
-#include "uassert.h"
-#include "digitinterval.h"
-#include "ucln_in.h"
-#include "umutex.h"
-#include "double-conversion.h"
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-#include <stdio.h>
-#include <limits>
-
-using icu::double_conversion::DoubleToStringConverter;
-
-#if !defined(U_USE_STRTOD_L)
-# if U_PLATFORM_USES_ONLY_WIN32_API
-#   define U_USE_STRTOD_L 1
-#   define U_HAVE_XLOCALE_H 0
-# elif defined(U_HAVE_STRTOD_L)
-#   define U_USE_STRTOD_L U_HAVE_STRTOD_L
-# else
-#   define U_USE_STRTOD_L 0
-# endif
-#endif
-
-#if U_USE_STRTOD_L
-# if U_HAVE_XLOCALE_H
-#   include <xlocale.h>
-# else
-#   include <locale.h>
-# endif
-#endif
-
-// ***************************************************************************
-// class DigitList
-//    A wrapper onto decNumber.
-//    Used to be standalone.
-// ***************************************************************************
-
-/**
- * This is the zero digit.  The base for the digits returned by getDigit()
- * Note that it is the platform invariant digit, and is not Unicode.
- */
-#define kZero '0'
-
-
-/* Only for 32 bit numbers. Ignore the negative sign. */
-//static const char LONG_MIN_REP[] = "2147483648";
-//static const char I64_MIN_REP[] = "9223372036854775808";
-
-
-U_NAMESPACE_BEGIN
-
-// -------------------------------------
-// default constructor
-
-DigitList::DigitList()
-{
-    uprv_decContextDefault(&fContext, DEC_INIT_BASE);
-    fContext.traps  = 0;
-    uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN);
-    fContext.digits = fStorage.getCapacity();
-
-    fDecNumber = fStorage.getAlias();
-    uprv_decNumberZero(fDecNumber);
-
-    internalSetDouble(0.0);
-}
-
-// -------------------------------------
-
-DigitList::~DigitList()
-{
-}
-
-// -------------------------------------
-// copy constructor
-
-DigitList::DigitList(const DigitList &other)
-{
-    fDecNumber = fStorage.getAlias();
-    *this = other;
-}
-
-
-// -------------------------------------
-// assignment operator
-
-DigitList&
-DigitList::operator=(const DigitList& other)
-{
-    if (this != &other)
-    {
-        uprv_memcpy(&fContext, &other.fContext, sizeof(decContext));
-
-        if (other.fStorage.getCapacity() > fStorage.getCapacity()) {
-            fDecNumber = fStorage.resize(other.fStorage.getCapacity());
-        }
-        // Always reset the fContext.digits, even if fDecNumber was not reallocated,
-        // because above we copied fContext from other.fContext.
-        fContext.digits = fStorage.getCapacity();
-        uprv_decNumberCopy(fDecNumber, other.fDecNumber);
-
-        {
-            // fDouble is lazily created and cached.
-            // Avoid potential races with that happening with other.fDouble
-            // while we are doing the assignment.
-            Mutex mutex;
-
-            if(other.fHave==kDouble) {
-                fUnion.fDouble = other.fUnion.fDouble;
-            }
-            fHave = other.fHave;
-        }
-    }
-    return *this;
-}
-
-// -------------------------------------
-//    operator ==  (does not exactly match the old DigitList function)
-
-UBool
-DigitList::operator==(const DigitList& that) const
-{
-    if (this == &that) {
-        return TRUE;
-    }
-    decNumber n;  // Has space for only a none digit value.
-    decContext c;
-    uprv_decContextDefault(&c, DEC_INIT_BASE);
-    c.digits = 1;
-    c.traps = 0;
-
-    uprv_decNumberCompare(&n, this->fDecNumber, that.fDecNumber, &c);
-    UBool result = decNumberIsZero(&n);
-    return result;
-}
-
-// -------------------------------------
-//      comparison function.   Returns
-//         Not Comparable :  -2
-//                      < :  -1
-//                     == :   0
-//                      > :  +1
-int32_t DigitList::compare(const DigitList &other) {
-    decNumber   result;
-    int32_t     savedDigits = fContext.digits;
-    fContext.digits = 1;
-    uprv_decNumberCompare(&result, this->fDecNumber, other.fDecNumber, &fContext);
-    fContext.digits = savedDigits;
-    if (decNumberIsZero(&result)) {
-        return 0;
-    } else if (decNumberIsSpecial(&result)) {
-        return -2;
-    } else if (result.bits & DECNEG) {
-        return -1;
-    } else {
-        return 1;
-    }
-}
-
-
-// -------------------------------------
-//  Reduce - remove trailing zero digits.
-void
-DigitList::reduce() {
-    uprv_decNumberReduce(fDecNumber, fDecNumber, &fContext);
-}
-
-
-// -------------------------------------
-//  trim - remove trailing fraction zero digits.
-void
-DigitList::trim() {
-    uprv_decNumberTrim(fDecNumber);
-}
-
-// -------------------------------------
-// Resets the digit list; sets all the digits to zero.
-
-void
-DigitList::clear()
-{
-    uprv_decNumberZero(fDecNumber);
-    uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN);
-    internalSetDouble(0.0);
-}
-
-
-/**
- * Formats a int64_t number into a base 10 string representation, and NULL terminates it.
- * @param number The number to format
- * @param outputStr The string to output to.  Must be at least MAX_DIGITS+2 in length (21),
- *                  to hold the longest int64_t value.
- * @return the number of digits written, not including the sign.
- */
-static int32_t
-formatBase10(int64_t number, char *outputStr) {
-    // The number is output backwards, starting with the LSD.
-    // Fill the buffer from the far end.  After the number is complete,
-    // slide the string contents to the front.
-
-    const int32_t MAX_IDX = MAX_DIGITS+2;
-    int32_t destIdx = MAX_IDX;
-    outputStr[--destIdx] = 0;
-
-    int64_t  n = number;
-    if (number < 0) {   // Negative numbers are slightly larger than a postive
-        outputStr[--destIdx] = (char)(-(n % 10) + kZero);
-        n /= -10;
-    }
-    do {
-        outputStr[--destIdx] = (char)(n % 10 + kZero);
-        n /= 10;
-    } while (n > 0);
-
-    if (number < 0) {
-        outputStr[--destIdx] = '-';
-    }
-
-    // Slide the number to the start of the output str
-    U_ASSERT(destIdx >= 0);
-    int32_t length = MAX_IDX - destIdx;
-    uprv_memmove(outputStr, outputStr+MAX_IDX-length, length);
-
-    return length;
-}
-
-
-// -------------------------------------
-//
-//  setRoundingMode()
-//    For most modes, the meaning and names are the same between the decNumber library
-//      (which DigitList follows) and the ICU Formatting Rounding Mode values.
-//      The flag constants are different, however.
-//
-//     Note that ICU's kRoundingUnnecessary is not implemented directly by DigitList.
-//     This mode, inherited from Java, means that numbers that would not format exactly
-//     will return an error when formatting is attempted.
-
-void
-DigitList::setRoundingMode(DecimalFormat::ERoundingMode m) {
-    enum rounding r;
-
-    switch (m) {
-      case  DecimalFormat::kRoundCeiling:  r = DEC_ROUND_CEILING;   break;
-      case  DecimalFormat::kRoundFloor:    r = DEC_ROUND_FLOOR;     break;
-      case  DecimalFormat::kRoundDown:     r = DEC_ROUND_DOWN;      break;
-      case  DecimalFormat::kRoundUp:       r = DEC_ROUND_UP;        break;
-      case  DecimalFormat::kRoundHalfEven: r = DEC_ROUND_HALF_EVEN; break;
-      case  DecimalFormat::kRoundHalfDown: r = DEC_ROUND_HALF_DOWN; break;
-      case  DecimalFormat::kRoundHalfUp:   r = DEC_ROUND_HALF_UP;   break;
-      case  DecimalFormat::kRoundUnnecessary: r = DEC_ROUND_HALF_EVEN; break;
-      default:
-         // TODO: how to report the problem?
-         // Leave existing mode unchanged.
-         r = uprv_decContextGetRounding(&fContext);
-    }
-    uprv_decContextSetRounding(&fContext, r);
-
-}
-
-
-// -------------------------------------
-
-void
-DigitList::setPositive(UBool s) {
-    if (s) {
-        fDecNumber->bits &= ~DECNEG;
-    } else {
-        fDecNumber->bits |= DECNEG;
-    }
-    internalClear();
-}
-// -------------------------------------
-
-void
-DigitList::setDecimalAt(int32_t d) {
-    U_ASSERT((fDecNumber->bits & DECSPECIAL) == 0);  // Not Infinity or NaN
-    U_ASSERT(d-1>-999999999);
-    U_ASSERT(d-1< 999999999);
-    int32_t adjustedDigits = fDecNumber->digits;
-    if (decNumberIsZero(fDecNumber)) {
-        // Account for difference in how zero is represented between DigitList & decNumber.
-        adjustedDigits = 0;
-    }
-    fDecNumber->exponent = d - adjustedDigits;
-    internalClear();
-}
-
-int32_t
-DigitList::getDecimalAt() {
-    U_ASSERT((fDecNumber->bits & DECSPECIAL) == 0);  // Not Infinity or NaN
-    if (decNumberIsZero(fDecNumber) || ((fDecNumber->bits & DECSPECIAL) != 0)) {
-        return fDecNumber->exponent;  // Exponent should be zero for these cases.
-    }
-    return fDecNumber->exponent + fDecNumber->digits;
-}
-
-void
-DigitList::setCount(int32_t c)  {
-    U_ASSERT(c <= fContext.digits);
-    if (c == 0) {
-        // For a value of zero, DigitList sets all fields to zero, while
-        // decNumber keeps one digit (with that digit being a zero)
-        c = 1;
-        fDecNumber->lsu[0] = 0;
-    }
-    fDecNumber->digits = c;
-    internalClear();
-}
-
-int32_t
-DigitList::getCount() const {
-    if (decNumberIsZero(fDecNumber) && fDecNumber->exponent==0) {
-       // The extra test for exponent==0 is needed because parsing sometimes appends
-       // zero digits.  It's bogus, decimalFormatter parsing needs to be cleaned up.
-       return 0;
-    } else {
-       return fDecNumber->digits;
-    }
-}
-
-void
-DigitList::setDigit(int32_t i, char v) {
-    int32_t count = fDecNumber->digits;
-    U_ASSERT(i<count);
-    U_ASSERT(v>='0' && v<='9');
-    v &= 0x0f;
-    fDecNumber->lsu[count-i-1] = v;
-    internalClear();
-}
-
-char
-DigitList::getDigit(int32_t i) {
-    int32_t count = fDecNumber->digits;
-    U_ASSERT(i<count);
-    return fDecNumber->lsu[count-i-1] + '0';
-}
-
-// copied from DigitList::getDigit()
-uint8_t
-DigitList::getDigitValue(int32_t i) {
-    int32_t count = fDecNumber->digits;
-    U_ASSERT(i<count);
-    return fDecNumber->lsu[count-i-1];
-}
-
-// -------------------------------------
-// Appends the digit to the digit list if it's not out of scope.
-// Ignores the digit, otherwise.
-//
-// This function is horribly inefficient to implement with decNumber because
-// the digits are stored least significant first, which requires moving all
-// existing digits down one to make space for the new one to be appended.
-//
-void
-DigitList::append(char digit)
-{
-    U_ASSERT(digit>='0' && digit<='9');
-    // Ignore digits which exceed the precision we can represent
-    //    And don't fix for larger precision.  Fix callers instead.
-    if (decNumberIsZero(fDecNumber)) {
-        // Zero needs to be special cased because of the difference in the way
-        // that the old DigitList and decNumber represent it.
-        // digit cout was zero for digitList, is one for decNumber
-        fDecNumber->lsu[0] = digit & 0x0f;
-        fDecNumber->digits = 1;
-        fDecNumber->exponent--;     // To match the old digit list implementation.
-    } else {
-        int32_t nDigits = fDecNumber->digits;
-        if (nDigits < fContext.digits) {
-            int i;
-            for (i=nDigits; i>0; i--) {
-                fDecNumber->lsu[i] = fDecNumber->lsu[i-1];
-            }
-            fDecNumber->lsu[0] = digit & 0x0f;
-            fDecNumber->digits++;
-            // DigitList emulation - appending doesn't change the magnitude of existing
-            //                       digits.  With decNumber's decimal being after the
-            //                       least signficant digit, we need to adjust the exponent.
-            fDecNumber->exponent--;
-        }
-    }
-    internalClear();
-}
-
-// -------------------------------------
-
-/**
- * Currently, getDouble() depends on strtod() to do its conversion.
- *
- * WARNING!!
- * This is an extremely costly function. ~1/2 of the conversion time
- * can be linked to this function.
- */
-double
-DigitList::getDouble() const
-{
-    {
-        Mutex mutex;
-        if (fHave == kDouble) {
-            return fUnion.fDouble;
-        }
-    }
-
-    double tDouble = 0.0;
-    if (isZero()) {
-        tDouble = 0.0;
-        if (decNumberIsNegative(fDecNumber)) {
-            tDouble /= -1;
-        }
-    } else if (isInfinite()) {
-        if (std::numeric_limits<double>::has_infinity) {
-            tDouble = std::numeric_limits<double>::infinity();
-        } else {
-            tDouble = std::numeric_limits<double>::max();
-        }
-        if (!isPositive()) {
-            tDouble = -tDouble; //this was incorrectly "-fDouble" originally.
-        }
-    } else {
-        MaybeStackArray<char, MAX_DBL_DIGITS+18> s;
-           // Note:  14 is a  magic constant from the decNumber library documentation,
-           //        the max number of extra characters beyond the number of digits
-           //        needed to represent the number in string form.  Add a few more
-           //        for the additional digits we retain.
-
-        // Round down to appx. double precision, if the number is longer than that.
-        // Copy the number first, so that we don't modify the original.
-        if (getCount() > MAX_DBL_DIGITS + 3) {
-            DigitList numToConvert(*this);
-            numToConvert.reduce();    // Removes any trailing zeros, so that digit count is good.
-            numToConvert.round(MAX_DBL_DIGITS+3);
-            uprv_decNumberToString(numToConvert.fDecNumber, s.getAlias());
-            // TODO:  how many extra digits should be included for an accurate conversion?
-        } else {
-            uprv_decNumberToString(this->fDecNumber, s.getAlias());
-        }
-        U_ASSERT(uprv_strlen(&s[0]) < MAX_DBL_DIGITS+18);
-
-        char *end = NULL;
-        tDouble = decimalStrToDouble(s.getAlias(), &end);
-    }
-    {
-        Mutex mutex;
-        DigitList *nonConstThis = const_cast<DigitList *>(this);
-        nonConstThis->internalSetDouble(tDouble);
-    }
-    return tDouble;
-}
-
-#if U_USE_STRTOD_L && U_PLATFORM_USES_ONLY_WIN32_API
-# define locale_t _locale_t
-# define freelocale _free_locale
-# define strtod_l _strtod_l
-#endif
-
-#if U_USE_STRTOD_L
-static locale_t gCLocale = (locale_t)0;
-#endif
-static icu::UInitOnce gCLocaleInitOnce = U_INITONCE_INITIALIZER;
-
-U_CDECL_BEGIN
-// Cleanup callback func
-static UBool U_CALLCONV digitList_cleanup(void)
-{
-#if U_USE_STRTOD_L
-    if (gCLocale != (locale_t)0) {
-        freelocale(gCLocale);
-    }
-#endif
-    return TRUE;
-}
-// C Locale initialization func
-static void U_CALLCONV initCLocale(void) {
-    ucln_i18n_registerCleanup(UCLN_I18N_DIGITLIST, digitList_cleanup);
-#if U_USE_STRTOD_L
-# if U_PLATFORM_USES_ONLY_WIN32_API
-    gCLocale = _create_locale(LC_ALL, "C");
-# else
-    gCLocale = newlocale(LC_ALL_MASK, "C", (locale_t)0);
-# endif
-#endif
-}
-U_CDECL_END
-
-double
-DigitList::decimalStrToDouble(char *decstr, char **end) {
-    umtx_initOnce(gCLocaleInitOnce, &initCLocale);
-#if U_USE_STRTOD_L
-    return strtod_l(decstr, end, gCLocale);
-#else
-    char *decimalPt = strchr(decstr, '.');
-    if (decimalPt) {
-        // We need to know the decimal separator character that will be used with strtod().
-        // Depends on the C runtime global locale.
-        // Most commonly is '.'
-        char rep[MAX_DIGITS];
-        sprintf(rep, "%+1.1f", 1.0);
-        *decimalPt = rep[2];
-    }
-    return uprv_strtod(decstr, end);
-#endif
-}
-
-// -------------------------------------
-
-/**
- *  convert this number to an int32_t.   Round if there is a fractional part.
- *  Return zero if the number cannot be represented.
- */
-int32_t DigitList::getLong() /*const*/
-{
-    int32_t result = 0;
-    if (getUpperExponent() > 10) {
-        // Overflow, absolute value too big.
-        return result;
-    }
-    if (fDecNumber->exponent != 0) {
-        // Force to an integer, with zero exponent, rounding if necessary.
-        //   (decNumberToInt32 will only work if the exponent is exactly zero.)
-        DigitList copy(*this);
-        DigitList zero;
-        uprv_decNumberQuantize(copy.fDecNumber, copy.fDecNumber, zero.fDecNumber, &fContext);
-        result = uprv_decNumberToInt32(copy.fDecNumber, &fContext);
-    } else {
-        result = uprv_decNumberToInt32(fDecNumber, &fContext);
-    }
-    return result;
-}
-
-
-/**
- *  convert this number to an int64_t.   Truncate if there is a fractional part.
- *  Return zero if the number cannot be represented.
- */
-int64_t DigitList::getInt64() /*const*/ {
-    // TODO: fast conversion if fHave == fDouble
-
-    // Truncate if non-integer.
-    // Return 0 if out of range.
-    // Range of in64_t is -9223372036854775808 to 9223372036854775807  (19 digits)
-    //
-    if (getUpperExponent() > 19) {
-        // Overflow, absolute value too big.
-        return 0;
-    }
-
-    // The number of integer digits may differ from the number of digits stored
-    //   in the decimal number.
-    //     for 12.345  numIntDigits = 2, number->digits = 5
-    //     for 12E4    numIntDigits = 6, number->digits = 2
-    // The conversion ignores the fraction digits in the first case,
-    // and fakes up extra zero digits in the second.
-    // TODO:  It would be faster to store a table of powers of ten to multiply by
-    //        instead of looping over zero digits, multiplying each time.
-
-    int32_t numIntDigits = getUpperExponent();
-    uint64_t value = 0;
-    for (int32_t i = 0; i < numIntDigits; i++) {
-        // Loop is iterating over digits starting with the most significant.
-        // Numbers are stored with the least significant digit at index zero.
-        int32_t digitIndex = fDecNumber->digits - i - 1;
-        int32_t v = (digitIndex >= 0) ? fDecNumber->lsu[digitIndex] : 0;
-        value = value * (uint64_t)10 + (uint64_t)v;
-    }
-
-    if (decNumberIsNegative(fDecNumber)) {
-        value = ~value;
-        value += 1;
-    }
-    int64_t svalue = (int64_t)value;
-
-    // Check overflow.  It's convenient that the MSD is 9 only on overflow, the amount of
-    //                  overflow can't wrap too far.  The test will also fail -0, but
-    //                  that does no harm; the right answer is 0.
-    if (numIntDigits == 19) {
-        if (( decNumberIsNegative(fDecNumber) && svalue>0) ||
-            (!decNumberIsNegative(fDecNumber) && svalue<0)) {
-            svalue = 0;
-        }
-    }
-
-    return svalue;
-}
-
-
-/**
- *  Return a string form of this number.
- *     Format is as defined by the decNumber library, for interchange of
- *     decimal numbers.
- */
-void DigitList::getDecimal(CharString &str, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-    // A decimal number in string form can, worst case, be 14 characters longer
-    //  than the number of digits.  So says the decNumber library doc.
-    int32_t maxLength = fDecNumber->digits + 14;
-    int32_t capacity = 0;
-    char *buffer = str.clear().getAppendBuffer(maxLength, 0, capacity, status);
-    if (U_FAILURE(status)) {
-        return;    // Memory allocation error on growing the string.
-    }
-    U_ASSERT(capacity >= maxLength);
-    uprv_decNumberToString(this->fDecNumber, buffer);
-    U_ASSERT((int32_t)uprv_strlen(buffer) <= maxLength);
-    str.append(buffer, -1, status);
-}
-
-/**
- * Return true if this is an integer value that can be held
- * by an int32_t type.
- */
-UBool
-DigitList::fitsIntoLong(UBool ignoreNegativeZero) /*const*/
-{
-    if (decNumberIsSpecial(this->fDecNumber)) {
-        // NaN or Infinity.  Does not fit in int32.
-        return FALSE;
-    }
-    uprv_decNumberTrim(this->fDecNumber);
-    if (fDecNumber->exponent < 0) {
-        // Number contains fraction digits.
-        return FALSE;
-    }
-    if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero &&
-        (fDecNumber->bits & DECNEG) != 0) {
-        // Negative Zero, not ingored.  Cannot represent as a long.
-        return FALSE;
-    }
-    if (getUpperExponent() < 10) {
-        // The number is 9 or fewer digits.
-        // The max and min int32 are 10 digts, so this number fits.
-        // This is the common case.
-        return TRUE;
-    }
-
-    // TODO:  Should cache these constants; construction is relatively costly.
-    //        But not of huge consequence; they're only needed for 10 digit ints.
-    UErrorCode status = U_ZERO_ERROR;
-    DigitList min32; min32.set("-2147483648", status);
-    if (this->compare(min32) < 0) {
-        return FALSE;
-    }
-    DigitList max32; max32.set("2147483647", status);
-    if (this->compare(max32) > 0) {
-        return FALSE;
-    }
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    return true;
-}
-
-
-
-/**
- * Return true if the number represented by this object can fit into
- * a long.
- */
-UBool
-DigitList::fitsIntoInt64(UBool ignoreNegativeZero) /*const*/
-{
-    if (decNumberIsSpecial(this->fDecNumber)) {
-        // NaN or Infinity.  Does not fit in int32.
-        return FALSE;
-    }
-    uprv_decNumberTrim(this->fDecNumber);
-    if (fDecNumber->exponent < 0) {
-        // Number contains fraction digits.
-        return FALSE;
-    }
-    if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero &&
-        (fDecNumber->bits & DECNEG) != 0) {
-        // Negative Zero, not ingored.  Cannot represent as a long.
-        return FALSE;
-    }
-    if (getUpperExponent() < 19) {
-        // The number is 18 or fewer digits.
-        // The max and min int64 are 19 digts, so this number fits.
-        // This is the common case.
-        return TRUE;
-    }
-
-    // TODO:  Should cache these constants; construction is relatively costly.
-    //        But not of huge consequence; they're only needed for 19 digit ints.
-    UErrorCode status = U_ZERO_ERROR;
-    DigitList min64; min64.set("-9223372036854775808", status);
-    if (this->compare(min64) < 0) {
-        return FALSE;
-    }
-    DigitList max64; max64.set("9223372036854775807", status);
-    if (this->compare(max64) > 0) {
-        return FALSE;
-    }
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    return true;
-}
-
-
-// -------------------------------------
-
-void
-DigitList::set(int32_t source)
-{
-    set((int64_t)source);
-    internalSetDouble(source);
-}
-
-// -------------------------------------
-/**
- * Set an int64, via decnumber
- */
-void
-DigitList::set(int64_t source)
-{
-    char str[MAX_DIGITS+2];   // Leave room for sign and trailing nul.
-    formatBase10(source, str);
-    U_ASSERT(uprv_strlen(str) < sizeof(str));
-
-    uprv_decNumberFromString(fDecNumber, str, &fContext);
-    internalSetDouble(static_cast<double>(source));
-}
-
-// -------------------------------------
-/**
- * Set the DigitList from a decimal number string.
- *
- * The incoming string _must_ be nul terminated, even though it is arriving
- * as a StringPiece because that is what the decNumber library wants.
- * We can get away with this for an internal function; it would not
- * be acceptable for a public API.
- */
-void
-DigitList::set(StringPiece source, UErrorCode &status, uint32_t /*fastpathBits*/) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-
-#if 0
-    if(fastpathBits==(kFastpathOk|kNoDecimal)) {
-      int32_t size = source.size();
-      const char *data = source.data();
-      int64_t r = 0;
-      int64_t m = 1;
-      // fast parse
-      while(size>0) {
-        char ch = data[--size];
-        if(ch=='+') {
-          break;
-        } else if(ch=='-') {
-          r = -r;
-          break;
-        } else {
-          int64_t d = ch-'0';
-          //printf("CH[%d]=%c, %d, *=%d\n", size,ch, (int)d, (int)m);
-          r+=(d)*m;
-          m *= 10;
-        }
-      }
-      //printf("R=%d\n", r);
-      set(r);
-    } else
-#endif
-        {
-      // Figure out a max number of digits to use during the conversion, and
-      // resize the number up if necessary.
-      int32_t numDigits = source.length();
-      if (numDigits > fContext.digits) {
-        // fContext.digits == fStorage.getCapacity()
-        decNumber *t = fStorage.resize(numDigits, fStorage.getCapacity());
-        if (t == NULL) {
-          status = U_MEMORY_ALLOCATION_ERROR;
-          return;
-        }
-        fDecNumber = t;
-        fContext.digits = numDigits;
-      }
-
-      fContext.status = 0;
-      uprv_decNumberFromString(fDecNumber, source.data(), &fContext);
-      if ((fContext.status & DEC_Conversion_syntax) != 0) {
-        status = U_DECIMAL_NUMBER_SYNTAX_ERROR;
-      }
-    }
-    internalClear();
-}
-
-/**
- * Set the digit list to a representation of the given double value.
- * This method supports both fixed-point and exponential notation.
- * @param source Value to be converted.
- */
-void
-DigitList::set(double source)
-{
-    // for now, simple implementation; later, do proper IEEE stuff
-    char rep[MAX_DIGITS + 8]; // Extra space for '+', '.', e+NNN, and '\0' (actually +8 is enough)
-
-    // Generate a representation of the form /[+-][0-9].[0-9]+e[+-][0-9]+/
-    // Can also generate /[+-]nan/ or /[+-]inf/
-    // TODO: Use something other than sprintf() here, since it's behavior is somewhat platform specific.
-    //       That is why infinity is special cased here.
-    if (uprv_isInfinite(source)) {
-        if (uprv_isNegativeInfinity(source)) {
-            uprv_strcpy(rep,"-inf"); // Handle negative infinity
-        } else {
-            uprv_strcpy(rep,"inf");
-        }
-    } else if (uprv_isNaN(source)) {
-        uprv_strcpy(rep, "NaN");
-    } else {
-        bool sign;
-        int32_t length;
-        int32_t point;
-        DoubleToStringConverter::DoubleToAscii(
-            source,
-            DoubleToStringConverter::DtoaMode::SHORTEST,
-            0,
-            rep + 1,
-            sizeof(rep),
-            &sign,
-            &length,
-            &point
-        );
-
-        // Convert the raw buffer into a string for decNumber
-        int32_t power = point - length;
-        if (sign) {
-            rep[0] = '-';
-        } else {
-            rep[0] = '0';
-        }
-        length++;
-        rep[length++] = 'E';
-        if (power < 0) {
-            rep[length++] = '-';
-            power = -power;
-        } else {
-            rep[length++] = '+';
-        }
-        if (power < 10) {
-            rep[length++] = power + '0';
-        } else if (power < 100) {
-            rep[length++] = (power / 10) + '0';
-            rep[length++] = (power % 10) + '0';
-        } else {
-            U_ASSERT(power < 1000);
-            rep[length + 2] = (power % 10) + '0';
-            power /= 10;
-            rep[length + 1] = (power % 10) + '0';
-            power /= 10;
-            rep[length] = power + '0';
-            length += 3;
-        }
-        rep[length++] = 0;
-    }
-    U_ASSERT(uprv_strlen(rep) < sizeof(rep));
-
-    // uprv_decNumberFromString() will parse the string expecting '.' as a
-    // decimal separator, however sprintf() can use ',' in certain locales.
-    // Overwrite a ',' with '.' here before proceeding.
-    char *decimalSeparator = strchr(rep, ',');
-    if (decimalSeparator != NULL) {
-        *decimalSeparator = '.';
-    }
-
-    // Create a decNumber from the string.
-    uprv_decNumberFromString(fDecNumber, rep, &fContext);
-    uprv_decNumberTrim(fDecNumber);
-    internalSetDouble(source);
-}
-
-// -------------------------------------
-
-/*
- * Multiply
- *      The number will be expanded if need be to retain full precision.
- *      In practice, for formatting, multiply is by 10, 100 or 1000, so more digits
- *      will not be required for this use.
- */
-void
-DigitList::mult(const DigitList &other, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    fContext.status = 0;
-    int32_t requiredDigits = this->digits() + other.digits();
-    if (requiredDigits > fContext.digits) {
-        reduce();    // Remove any trailing zeros
-        int32_t requiredDigits = this->digits() + other.digits();
-        ensureCapacity(requiredDigits, status);
-    }
-    uprv_decNumberMultiply(fDecNumber, fDecNumber, other.fDecNumber, &fContext);
-    internalClear();
-}
-
-// -------------------------------------
-
-/*
- * Divide
- *      The number will _not_ be expanded for inexact results.
- *      TODO:  probably should expand some, for rounding increments that
- *             could add a few digits, e.g. .25, but not expand arbitrarily.
- */
-void
-DigitList::div(const DigitList &other, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    uprv_decNumberDivide(fDecNumber, fDecNumber, other.fDecNumber, &fContext);
-    internalClear();
-}
-
-// -------------------------------------
-
-/*
- * ensureCapacity.   Grow the digit storage for the number if it's less than the requested
- *         amount.  Never reduce it.  Available size is kept in fContext.digits.
- */
-void
-DigitList::ensureCapacity(int32_t requestedCapacity, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    if (requestedCapacity <= 0) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return;
-    }
-    if (requestedCapacity > DEC_MAX_DIGITS) {
-        // Don't report an error for requesting too much.
-        // Arithemetic Results will be rounded to what can be supported.
-        //   At 999,999,999 max digits, exceeding the limit is not too likely!
-        requestedCapacity = DEC_MAX_DIGITS;
-    }
-    if (requestedCapacity > fContext.digits) {
-        decNumber *newBuffer = fStorage.resize(requestedCapacity, fStorage.getCapacity());
-        if (newBuffer == NULL) {
-            status = U_MEMORY_ALLOCATION_ERROR;
-            return;
-        }
-        fContext.digits = requestedCapacity;
-        fDecNumber = newBuffer;
-    }
-}
-
-// -------------------------------------
-
-/**
- * Round the representation to the given number of digits.
- * @param maximumDigits The maximum number of digits to be shown.
- * Upon return, count will be less than or equal to maximumDigits.
- */
-void
-DigitList::round(int32_t maximumDigits)
-{
-    reduce();
-    if (maximumDigits >= fDecNumber->digits) {
-        return;
-    }
-    int32_t savedDigits  = fContext.digits;
-    fContext.digits = maximumDigits;
-    uprv_decNumberPlus(fDecNumber, fDecNumber, &fContext);
-    fContext.digits = savedDigits;
-    uprv_decNumberTrim(fDecNumber);
-    reduce();
-    internalClear();
-}
-
-
-void
-DigitList::roundFixedPoint(int32_t maximumFractionDigits) {
-    reduce();        // Remove trailing zeros.
-    if (fDecNumber->exponent >= -maximumFractionDigits) {
-        return;
-    }
-    decNumber scale;   // Dummy decimal number, but with the desired number of
-    uprv_decNumberZero(&scale);    //    fraction digits.
-    scale.exponent = -maximumFractionDigits;
-    scale.lsu[0] = 1;
-
-    uprv_decNumberQuantize(fDecNumber, fDecNumber, &scale, &fContext);
-    reduce();
-    internalClear();
-}
-
-// -------------------------------------
-
-void
-DigitList::toIntegralValue() {
-    uprv_decNumberToIntegralValue(fDecNumber, fDecNumber, &fContext);
-}
-
-
-// -------------------------------------
-UBool
-DigitList::isZero() const
-{
-    return decNumberIsZero(fDecNumber);
-}
-
-// -------------------------------------
-int32_t
-DigitList::getUpperExponent() const {
-    return fDecNumber->digits + fDecNumber->exponent;
-}
-
-DigitInterval &
-DigitList::getSmallestInterval(DigitInterval &result) const {
-    result.setLeastSignificantInclusive(fDecNumber->exponent);
-    result.setMostSignificantExclusive(getUpperExponent());
-    return result;
-}
-
-uint8_t
-DigitList::getDigitByExponent(int32_t exponent) const {
-    int32_t idx = exponent - fDecNumber->exponent;
-    if (idx < 0 || idx >= fDecNumber->digits) {
-        return 0;
-    }
-    return fDecNumber->lsu[idx];
-}
-
-void
-DigitList::appendDigitsTo(CharString &str, UErrorCode &status) const {
-    str.append((const char *) fDecNumber->lsu, fDecNumber->digits, status);
-}
-
-void
-DigitList::roundAtExponent(int32_t exponent, int32_t maxSigDigits) {
-    reduce();
-    if (maxSigDigits < fDecNumber->digits) {
-        int32_t minExponent = getUpperExponent() - maxSigDigits;
-        if (exponent < minExponent) {
-            exponent = minExponent;
-        }
-    }
-    if (exponent <= fDecNumber->exponent) {
-        return;
-    }
-    int32_t digits = getUpperExponent() - exponent;
-    if (digits > 0) {
-        round(digits);
-    } else {
-        roundFixedPoint(-exponent);
-    }
-}
-
-void
-DigitList::quantize(const DigitList &quantity, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return;
-    }
-    div(quantity, status);
-    roundAtExponent(0);
-    mult(quantity, status);
-    reduce();
-}
-
-int32_t
-DigitList::getScientificExponent(
-        int32_t minIntDigitCount, int32_t exponentMultiplier) const {
-    // The exponent for zero is always zero.
-    if (isZero()) {
-        return 0;
-    }
-    int32_t intDigitCount = getUpperExponent();
-    int32_t exponent;
-    if (intDigitCount >= minIntDigitCount) {
-        int32_t maxAdjustment = intDigitCount - minIntDigitCount;
-        exponent = (maxAdjustment / exponentMultiplier) * exponentMultiplier;
-    } else {
-        int32_t minAdjustment = minIntDigitCount - intDigitCount;
-        exponent = ((minAdjustment + exponentMultiplier - 1) / exponentMultiplier) * -exponentMultiplier;
-    }
-    return exponent;
-}
-
-int32_t
-DigitList::toScientific(
-        int32_t minIntDigitCount, int32_t exponentMultiplier) {
-    int32_t exponent = getScientificExponent(
-            minIntDigitCount, exponentMultiplier);
-    shiftDecimalRight(-exponent);
-    return exponent;
-}
-
-void
-DigitList::shiftDecimalRight(int32_t n) {
-    fDecNumber->exponent += n;
-    internalClear();
-}
-
-U_NAMESPACE_END
-#endif // #if !UCONFIG_NO_FORMATTING
-
-//eof
diff --git a/deps/icu-small/source/i18n/digitlst.h b/deps/icu-small/source/i18n/digitlst.h
deleted file mode 100644
index 6befaf32e6f340..00000000000000
--- a/deps/icu-small/source/i18n/digitlst.h
+++ /dev/null
@@ -1,529 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1997-2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*
-* File DIGITLST.H
-*
-* Modification History:
-*
-*   Date        Name        Description
-*   02/25/97    aliu        Converted from java.
-*   03/21/97    clhuang     Updated per C++ implementation.
-*   04/15/97    aliu        Changed MAX_COUNT to DBL_DIG.  Changed Digit to char.
-*   09/09/97    aliu        Adapted for exponential notation support.
-*   08/02/98    stephen     Added nearest/even rounding
-*   06/29/99    stephen     Made LONG_DIGITS a macro to satisfy SUN compiler
-*   07/09/99    stephen     Removed kMaxCount (unused, for HP compiler)
-******************************************************************************
-*/
-
-#ifndef DIGITLST_H
-#define DIGITLST_H
-
-#include "unicode/uobject.h"
-
-#if !UCONFIG_NO_FORMATTING
-#include "unicode/decimfmt.h"
-#include <float.h>
-#include "decContext.h"
-#include "decNumber.h"
-#include "cmemory.h"
-
-// Decimal digits in a 64-bit int
-#define INT64_DIGITS 19
-
-typedef enum EDigitListValues {
-    MAX_DBL_DIGITS = DBL_DIG,
-    MAX_I64_DIGITS = INT64_DIGITS,
-    MAX_DIGITS = MAX_I64_DIGITS,
-    MAX_EXPONENT = DBL_DIG,
-    DIGIT_PADDING = 3,
-    DEFAULT_DIGITS = 40,   // Initial storage size, will grow as needed.
-
-     // "+." + fDigits + "e" + fDecimalAt
-    MAX_DEC_DIGITS = MAX_DIGITS + DIGIT_PADDING + MAX_EXPONENT
-} EDigitListValues;
-
-U_NAMESPACE_BEGIN
-
-class CharString;
-class DigitInterval;
-
-// Export an explicit template instantiation of the MaybeStackHeaderAndArray that
-//    is used as a data member of DigitList.
-//
-//    MSVC requires this, even though it should not be necessary.
-//    No direct access to the MaybeStackHeaderAndArray leaks out of the i18n library.
-//
-//    Macintosh produces duplicate definition linker errors with the explicit template
-//    instantiation.
-//
-#if !U_PLATFORM_IS_DARWIN_BASED
-template class U_I18N_API MaybeStackHeaderAndArray<decNumber, char, DEFAULT_DIGITS>;
-#endif
-
-
-enum EStackMode { kOnStack };
-
-enum EFastpathBits { kFastpathOk = 1, kNoDecimal = 2 };
-
-/**
- * Digit List is actually a Decimal Floating Point number.
- * The original implementation has been replaced by a thin wrapper onto a
- * decimal number from the decNumber library.
- *
- * The original DigitList API has been retained, to minimize the impact of
- * the change on the rest of the ICU formatting code.
- *
- * The change to decNumber enables support for big decimal numbers, and
- * allows rounding computations to be done directly in decimal, avoiding
- * extra, and inaccurate, conversions to and from doubles.
- *
- * Original DigitList comments:
- *
- * Digit List utility class. Private to DecimalFormat.  Handles the transcoding
- * between numeric values and strings of characters.  Only handles
- * non-negative numbers.  The division of labor between DigitList and
- * DecimalFormat is that DigitList handles the radix 10 representation
- * issues; DecimalFormat handles the locale-specific issues such as
- * positive/negative, grouping, decimal point, currency, and so on.
- * <P>
- * A DigitList is really a representation of a floating point value.
- * It may be an integer value; we assume that a double has sufficient
- * precision to represent all digits of a long.
- * <P>
- * The DigitList representation consists of a string of characters,
- * which are the digits radix 10, from '0' to '9'.  It also has a radix
- * 10 exponent associated with it.  The value represented by a DigitList
- * object can be computed by mulitplying the fraction f, where 0 <= f < 1,
- * derived by placing all the digits of the list to the right of the
- * decimal point, by 10^exponent.
- *
- * --------
- *
- * DigitList vs. decimalNumber:
- *
- *    DigitList stores digits with the most significant first.
- *    decNumber stores digits with the least significant first.
- *
- *    DigitList, decimal point is before the most significant.
- *    decNumber, decimal point is after the least signficant digit.
- *
- *       digitList:    0.ddddd * 10 ^ exp
- *       decNumber:    ddddd. * 10 ^ exp
- *
- *       digitList exponent = decNumber exponent + digit count
- *
- *    digitList, digits are platform invariant chars, '0' - '9'
- *    decNumber, digits are binary, one per byte, 0 - 9.
- *
- *       (decNumber library is configurable in how digits are stored, ICU has configured
- *        it this way for convenience in replacing the old DigitList implementation.)
- */
-class U_I18N_API DigitList : public UMemory { // Declare external to make compiler happy
-public:
-
-    DigitList();
-    ~DigitList();
-
-    /* copy constructor
-     * @param DigitList The object to be copied.
-     * @return the newly created object.
-     */
-    DigitList(const DigitList&); // copy constructor
-
-    /* assignment operator
-     * @param DigitList The object to be copied.
-     * @return the newly created object.
-     */
-    DigitList& operator=(const DigitList&);  // assignment operator
-
-    /**
-     * Return true if another object is semantically equal to this one.
-     * @param other The DigitList to be compared for equality
-     * @return true if another object is semantically equal to this one.
-     * return false otherwise.
-     */
-    UBool operator==(const DigitList& other) const;
-
-    int32_t  compare(const DigitList& other);
-
-
-    inline UBool operator!=(const DigitList& other) const { return !operator==(other); }
-
-    /**
-     * Clears out the digits.
-     * Use before appending them.
-     * Typically, you set a series of digits with append, then at the point
-     * you hit the decimal point, you set myDigitList.fDecimalAt = myDigitList.fCount;
-     * then go on appending digits.
-     */
-    void clear(void);
-
-    /**
-     *  Remove, by rounding, any fractional part of the decimal number,
-     *  leaving an integer value.
-     */
-    void toIntegralValue();
-
-    /**
-     * Appends digits to the list.
-     *    CAUTION:  this function is not recommended for new code.
-     *              In the original DigitList implementation, decimal numbers were
-     *              parsed by appending them to a digit list as they were encountered.
-     *              With the revamped DigitList based on decNumber, append is very
-     *              inefficient, and the interaction with the exponent value is confusing.
-     *              Best avoided.
-     *              TODO:  remove this function once all use has been replaced.
-     *              TODO:  describe alternative to append()
-     * @param digit The digit to be appended.
-     */
-    void append(char digit);
-
-    /**
-     * Utility routine to get the value of the digit list
-     * Returns 0.0 if zero length.
-     * @return the value of the digit list.
-     */
-    double getDouble(void) const;
-
-    /**
-     * Utility routine to get the value of the digit list
-     * Make sure that fitsIntoLong() is called before calling this function.
-     * Returns 0 if zero length.
-     * @return the value of the digit list, return 0 if it is zero length
-     */
-    int32_t getLong(void) /*const*/;
-
-    /**
-     * Utility routine to get the value of the digit list
-     * Make sure that fitsIntoInt64() is called before calling this function.
-     * Returns 0 if zero length.
-     * @return the value of the digit list, return 0 if it is zero length
-     */
-    int64_t getInt64(void) /*const*/;
-
-    /**
-     *  Utility routine to get the value of the digit list as a decimal string.
-     */
-    void getDecimal(CharString &str, UErrorCode &status);
-
-    /**
-     * Return true if the number represented by this object can fit into
-     * a long.
-     * @param ignoreNegativeZero True if negative zero is ignored.
-     * @return true if the number represented by this object can fit into
-     * a long, return false otherwise.
-     */
-    UBool fitsIntoLong(UBool ignoreNegativeZero) /*const*/;
-
-    /**
-     * Return true if the number represented by this object can fit into
-     * an int64_t.
-     * @param ignoreNegativeZero True if negative zero is ignored.
-     * @return true if the number represented by this object can fit into
-     * a long, return false otherwise.
-     */
-    UBool fitsIntoInt64(UBool ignoreNegativeZero) /*const*/;
-
-    /**
-     * Utility routine to set the value of the digit list from a double.
-     * @param source The value to be set
-     */
-    void set(double source);
-
-    /**
-     * Utility routine to set the value of the digit list from a long.
-     * If a non-zero maximumDigits is specified, no more than that number of
-     * significant digits will be produced.
-     * @param source The value to be set
-     */
-    void set(int32_t source);
-
-    /**
-     * Utility routine to set the value of the digit list from an int64.
-     * If a non-zero maximumDigits is specified, no more than that number of
-     * significant digits will be produced.
-     * @param source The value to be set
-     */
-    void set(int64_t source);
-
-    /**
-     * Utility routine to set the value of the digit list from an int64.
-     * Does not set the decnumber unless requested later
-     * If a non-zero maximumDigits is specified, no more than that number of
-     * significant digits will be produced.
-     * @param source The value to be set
-     */
-    void setInteger(int64_t source);
-
-   /**
-     * Utility routine to set the value of the digit list from a decimal number
-     * string.
-     * @param source The value to be set.  The string must be nul-terminated.
-     * @param fastpathBits special flags for fast parsing
-     */
-    void set(StringPiece source, UErrorCode &status, uint32_t fastpathBits = 0);
-
-    /**
-     * Multiply    this = this * arg
-     *    This digitlist will be expanded if necessary to accomodate the result.
-     *  @param arg  the number to multiply by.
-     */
-    void mult(const DigitList &arg, UErrorCode &status);
-
-    /**
-     *   Divide    this = this / arg
-     */
-    void div(const DigitList &arg, UErrorCode &status);
-
-    //  The following functions replace direct access to the original DigitList implmentation
-    //  data structures.
-
-    void setRoundingMode(DecimalFormat::ERoundingMode m);
-
-    /** Test a number for zero.
-     * @return  TRUE if the number is zero
-     */
-    UBool isZero(void) const;
-
-    /** Test for a Nan
-     * @return  TRUE if the number is a NaN
-     */
-    UBool isNaN(void) const {return decNumberIsNaN(fDecNumber);}
-
-    UBool isInfinite() const {return decNumberIsInfinite(fDecNumber);}
-
-    /**  Reduce, or normalize.  Removes trailing zeroes, adjusts exponent appropriately. */
-    void     reduce();
-
-    /**  Remove trailing fraction zeros, adjust exponent accordingly. */
-    void     trim();
-
-    /** Set to zero */
-    void     setToZero() {uprv_decNumberZero(fDecNumber);}
-
-    /** get the number of digits in the decimal number */
-    int32_t  digits() const {return fDecNumber->digits;}
-
-    /**
-     * Round the number to the given number of digits.
-     * @param maximumDigits The maximum number of digits to be shown.
-     * Upon return, count will be less than or equal to maximumDigits.
-     * result is guaranteed to be trimmed.
-     */
-    void round(int32_t maximumDigits);
-
-    void roundFixedPoint(int32_t maximumFractionDigits);
-
-    /** Ensure capacity for digits.  Grow the storage if it is currently less than
-     *      the requested size.   Capacity is not reduced if it is already greater
-     *      than requested.
-     */
-    void  ensureCapacity(int32_t  requestedSize, UErrorCode &status);
-
-    UBool    isPositive(void) const { return decNumberIsNegative(fDecNumber) == 0;}
-    void     setPositive(UBool s);
-
-    void     setDecimalAt(int32_t d);
-    int32_t  getDecimalAt();
-
-    void     setCount(int32_t c);
-    int32_t  getCount() const;
-
-    /**
-     * Set the digit in platform (invariant) format, from '0'..'9'
-     * @param i index of digit
-     * @param v digit value, from '0' to '9' in platform invariant format
-     */
-    void     setDigit(int32_t i, char v);
-
-    /**
-     * Get the digit in platform (invariant) format, from '0'..'9' inclusive
-     * @param i index of digit
-     * @return invariant format of the digit
-     */
-    char     getDigit(int32_t i);
-
-
-    /**
-     * Get the digit's value, as an integer from 0..9 inclusive.
-     * Note that internally this value is a decNumberUnit, but ICU configures it to be a uint8_t.
-     * @param i index of digit
-     * @return value of that digit
-     */
-    uint8_t     getDigitValue(int32_t i);
-
-    /**
-     * Gets the upper bound exponent for this value. For 987, returns 3
-     * because 10^3 is the smallest power of 10 that is just greater than
-     * 987.
-     */
-    int32_t getUpperExponent() const;
-
-    /**
-     * Gets the lower bound exponent for this value. For 98.7, returns -1
-     * because the right most digit, is the 10^-1 place.
-     */
-    int32_t getLowerExponent() const { return fDecNumber->exponent; }
-
-    /**
-     * Sets result to the smallest DigitInterval needed to display this
-     * DigitList in fixed point form and returns result.
-     */
-    DigitInterval& getSmallestInterval(DigitInterval &result) const;
-
-    /**
-     * Like getDigitValue, but the digit is identified by exponent.
-     * For example, getDigitByExponent(7) returns the 10^7 place of this
-     * DigitList. Unlike getDigitValue, there are no upper or lower bounds
-     * for passed parameter. Instead, getDigitByExponent returns 0 if
-     * the exponent falls outside the interval for this DigitList.
-     */
-    uint8_t getDigitByExponent(int32_t exponent) const;
-
-    /**
-     * Appends the digits in this object to a CharString.
-     * 3 is appended as (char) 3, not '3'
-     */
-    void appendDigitsTo(CharString &str, UErrorCode &status) const;
-
-    /**
-     * Equivalent to roundFixedPoint(-digitExponent) except unlike
-     * roundFixedPoint, this works for any digitExponent value.
-     * If maxSigDigits is set then this instance is rounded to have no more
-     * than maxSigDigits. The end result is guaranteed to be trimmed.
-     */
-    void roundAtExponent(int32_t digitExponent, int32_t maxSigDigits=INT32_MAX);
-
-    /**
-     * Quantizes according to some amount and rounds according to the
-     * context of this instance. Quantizing 3.233 with 0.05 gives 3.25.
-     */
-    void quantize(const DigitList &amount, UErrorCode &status);
-
-    /**
-     * Like toScientific but only returns the exponent
-     * leaving this instance unchanged.
-     */
-    int32_t getScientificExponent(
-            int32_t minIntDigitCount, int32_t exponentMultiplier) const;
-
-    /**
-     * Converts this instance to scientific notation. This instance
-     * becomes the mantissa and the exponent is returned.
-     * @param minIntDigitCount minimum integer digits in mantissa
-     *   Exponent is set so that the actual number of integer digits
-     *   in mantissa is as close to the minimum as possible.
-     * @param exponentMultiplier The exponent is always a multiple of
-     *  This number. Usually 1, but set to 3 for engineering notation.
-     * @return exponent
-     */
-    int32_t toScientific(
-            int32_t minIntDigitCount, int32_t exponentMultiplier);
-
-    /**
-     * Shifts decimal to the right.
-     */
-    void shiftDecimalRight(int32_t numPlaces);
-
-private:
-    /*
-     * These data members are intentionally public and can be set directly.
-     *<P>
-     * The value represented is given by placing the decimal point before
-     * fDigits[fDecimalAt].  If fDecimalAt is < 0, then leading zeros between
-     * the decimal point and the first nonzero digit are implied.  If fDecimalAt
-     * is > fCount, then trailing zeros between the fDigits[fCount-1] and the
-     * decimal point are implied.
-     * <P>
-     * Equivalently, the represented value is given by f * 10^fDecimalAt.  Here
-     * f is a value 0.1 <= f < 1 arrived at by placing the digits in fDigits to
-     * the right of the decimal.
-     * <P>
-     * DigitList is normalized, so if it is non-zero, fDigits[0] is non-zero.  We
-     * don't allow denormalized numbers because our exponent is effectively of
-     * unlimited magnitude.  The fCount value contains the number of significant
-     * digits present in fDigits[].
-     * <P>
-     * Zero is represented by any DigitList with fCount == 0 or with each fDigits[i]
-     * for all i <= fCount == '0'.
-     *
-     * int32_t                         fDecimalAt;
-     * int32_t                         fCount;
-     * UBool                           fIsPositive;
-     * char                            *fDigits;
-     * DecimalFormat::ERoundingMode    fRoundingMode;
-     */
-
-public:
-    decContext    fContext;   // public access to status flags.
-
-private:
-    decNumber     *fDecNumber;
-    MaybeStackHeaderAndArray<decNumber, char, DEFAULT_DIGITS>  fStorage;
-
-    /* Cached double value corresponding to this decimal number.
-     * This is an optimization for the formatting implementation, which may
-     * ask for the double value multiple times.
-     */
-    union DoubleOrInt64 {
-      double        fDouble;
-      int64_t       fInt64;
-    } fUnion;
-    enum EHave {
-      kNone=0,
-      kDouble
-    } fHave;
-
-
-
-    UBool shouldRoundUp(int32_t maximumDigits) const;
-
- public:
-
-#if U_OVERRIDE_CXX_ALLOCATION
-    using UMemory::operator new;
-    using UMemory::operator delete;
-#else
-    static inline void * U_EXPORT2 operator new(size_t size) U_NO_THROW { return ::operator new(size); };
-    static inline void U_EXPORT2 operator delete(void *ptr )  U_NO_THROW { ::operator delete(ptr); };
-#endif
-
-    static double U_EXPORT2 decimalStrToDouble(char *decstr, char **end);
-
-    /**
-     * Placement new for stack usage
-     * @internal
-     */
-    static inline void * U_EXPORT2 operator new(size_t /*size*/, void * onStack, EStackMode  /*mode*/) U_NO_THROW { return onStack; }
-
-    /**
-     * Placement delete for stack usage
-     * @internal
-     */
-    static inline void U_EXPORT2 operator delete(void * /*ptr*/, void * /*onStack*/, EStackMode /*mode*/)  U_NO_THROW {}
-
- private:
-    inline void internalSetDouble(double d) {
-      fHave = kDouble;
-      fUnion.fDouble=d;
-    }
-    inline void internalClear() {
-      fHave = kNone;
-    }
-};
-
-
-U_NAMESPACE_END
-
-#endif // #if !UCONFIG_NO_FORMATTING
-#endif // _DIGITLST
-
-//eof
diff --git a/deps/icu-small/source/i18n/double-conversion-strtod.cpp b/deps/icu-small/source/i18n/double-conversion-strtod.cpp
new file mode 100644
index 00000000000000..be9b0b3bce0e76
--- /dev/null
+++ b/deps/icu-small/source/i18n/double-conversion-strtod.cpp
@@ -0,0 +1,574 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+//
+// From the double-conversion library. Original license:
+//
+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ICU PATCH: ifdef around UCONFIG_NO_FORMATTING
+#include "unicode/utypes.h"
+#if !UCONFIG_NO_FORMATTING
+
+#include <stdarg.h>
+#include <limits.h>
+
+// ICU PATCH: Customize header file paths for ICU.
+// The file fixed-dtoa.h is not needed.
+
+#include "double-conversion-strtod.h"
+#include "double-conversion-bignum.h"
+#include "double-conversion-cached-powers.h"
+#include "double-conversion-ieee.h"
+
+// ICU PATCH: Wrap in ICU namespace
+U_NAMESPACE_BEGIN
+
+namespace double_conversion {
+
+// 2^53 = 9007199254740992.
+// Any integer with at most 15 decimal digits will hence fit into a double
+// (which has a 53bit significand) without loss of precision.
+static const int kMaxExactDoubleIntegerDecimalDigits = 15;
+// 2^64 = 18446744073709551616 > 10^19
+static const int kMaxUint64DecimalDigits = 19;
+
+// Max double: 1.7976931348623157 x 10^308
+// Min non-zero double: 4.9406564584124654 x 10^-324
+// Any x >= 10^309 is interpreted as +infinity.
+// Any x <= 10^-324 is interpreted as 0.
+// Note that 2.5e-324 (despite being smaller than the min double) will be read
+// as non-zero (equal to the min non-zero double).
+static const int kMaxDecimalPower = 309;
+static const int kMinDecimalPower = -324;
+
+// 2^64 = 18446744073709551616
+static const uint64_t kMaxUint64 = UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF);
+
+
+static const double exact_powers_of_ten[] = {
+  1.0,  // 10^0
+  10.0,
+  100.0,
+  1000.0,
+  10000.0,
+  100000.0,
+  1000000.0,
+  10000000.0,
+  100000000.0,
+  1000000000.0,
+  10000000000.0,  // 10^10
+  100000000000.0,
+  1000000000000.0,
+  10000000000000.0,
+  100000000000000.0,
+  1000000000000000.0,
+  10000000000000000.0,
+  100000000000000000.0,
+  1000000000000000000.0,
+  10000000000000000000.0,
+  100000000000000000000.0,  // 10^20
+  1000000000000000000000.0,
+  // 10^22 = 0x21e19e0c9bab2400000 = 0x878678326eac9 * 2^22
+  10000000000000000000000.0
+};
+static const int kExactPowersOfTenSize = ARRAY_SIZE(exact_powers_of_ten);
+
+// Maximum number of significant digits in the decimal representation.
+// In fact the value is 772 (see conversions.cc), but to give us some margin
+// we round up to 780.
+static const int kMaxSignificantDecimalDigits = 780;
+
+static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
+  for (int i = 0; i < buffer.length(); i++) {
+    if (buffer[i] != '0') {
+      return buffer.SubVector(i, buffer.length());
+    }
+  }
+  return Vector<const char>(buffer.start(), 0);
+}
+
+
+static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
+  for (int i = buffer.length() - 1; i >= 0; --i) {
+    if (buffer[i] != '0') {
+      return buffer.SubVector(0, i + 1);
+    }
+  }
+  return Vector<const char>(buffer.start(), 0);
+}
+
+
+static void CutToMaxSignificantDigits(Vector<const char> buffer,
+                                       int exponent,
+                                       char* significant_buffer,
+                                       int* significant_exponent) {
+  for (int i = 0; i < kMaxSignificantDecimalDigits - 1; ++i) {
+    significant_buffer[i] = buffer[i];
+  }
+  // The input buffer has been trimmed. Therefore the last digit must be
+  // different from '0'.
+  ASSERT(buffer[buffer.length() - 1] != '0');
+  // Set the last digit to be non-zero. This is sufficient to guarantee
+  // correct rounding.
+  significant_buffer[kMaxSignificantDecimalDigits - 1] = '1';
+  *significant_exponent =
+      exponent + (buffer.length() - kMaxSignificantDecimalDigits);
+}
+
+
+// Trims the buffer and cuts it to at most kMaxSignificantDecimalDigits.
+// If possible the input-buffer is reused, but if the buffer needs to be
+// modified (due to cutting), then the input needs to be copied into the
+// buffer_copy_space.
+static void TrimAndCut(Vector<const char> buffer, int exponent,
+                       char* buffer_copy_space, int space_size,
+                       Vector<const char>* trimmed, int* updated_exponent) {
+  Vector<const char> left_trimmed = TrimLeadingZeros(buffer);
+  Vector<const char> right_trimmed = TrimTrailingZeros(left_trimmed);
+  exponent += left_trimmed.length() - right_trimmed.length();
+  if (right_trimmed.length() > kMaxSignificantDecimalDigits) {
+    (void) space_size;  // Mark variable as used.
+    ASSERT(space_size >= kMaxSignificantDecimalDigits);
+    CutToMaxSignificantDigits(right_trimmed, exponent,
+                              buffer_copy_space, updated_exponent);
+    *trimmed = Vector<const char>(buffer_copy_space,
+                                 kMaxSignificantDecimalDigits);
+  } else {
+    *trimmed = right_trimmed;
+    *updated_exponent = exponent;
+  }
+}
+
+
+// Reads digits from the buffer and converts them to a uint64.
+// Reads in as many digits as fit into a uint64.
+// When the string starts with "1844674407370955161" no further digit is read.
+// Since 2^64 = 18446744073709551616 it would still be possible read another
+// digit if it was less or equal than 6, but this would complicate the code.
+static uint64_t ReadUint64(Vector<const char> buffer,
+                           int* number_of_read_digits) {
+  uint64_t result = 0;
+  int i = 0;
+  while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
+    int digit = buffer[i++] - '0';
+    ASSERT(0 <= digit && digit <= 9);
+    result = 10 * result + digit;
+  }
+  *number_of_read_digits = i;
+  return result;
+}
+
+
+// Reads a DiyFp from the buffer.
+// The returned DiyFp is not necessarily normalized.
+// If remaining_decimals is zero then the returned DiyFp is accurate.
+// Otherwise it has been rounded and has error of at most 1/2 ulp.
+static void ReadDiyFp(Vector<const char> buffer,
+                      DiyFp* result,
+                      int* remaining_decimals) {
+  int read_digits;
+  uint64_t significand = ReadUint64(buffer, &read_digits);
+  if (buffer.length() == read_digits) {
+    *result = DiyFp(significand, 0);
+    *remaining_decimals = 0;
+  } else {
+    // Round the significand.
+    if (buffer[read_digits] >= '5') {
+      significand++;
+    }
+    // Compute the binary exponent.
+    int exponent = 0;
+    *result = DiyFp(significand, exponent);
+    *remaining_decimals = buffer.length() - read_digits;
+  }
+}
+
+
+static bool DoubleStrtod(Vector<const char> trimmed,
+                         int exponent,
+                         double* result) {
+#if !defined(DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
+  // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
+  // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
+  // result is not accurate.
+  // We know that Windows32 uses 64 bits and is therefore accurate.
+  // Note that the ARM simulator is compiled for 32bits. It therefore exhibits
+  // the same problem.
+  return false;
+#endif
+  if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
+    int read_digits;
+    // The trimmed input fits into a double.
+    // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
+    // can compute the result-double simply by multiplying (resp. dividing) the
+    // two numbers.
+    // This is possible because IEEE guarantees that floating-point operations
+    // return the best possible approximation.
+    if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
+      // 10^-exponent fits into a double.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result /= exact_powers_of_ten[-exponent];
+      return true;
+    }
+    if (0 <= exponent && exponent < kExactPowersOfTenSize) {
+      // 10^exponent fits into a double.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result *= exact_powers_of_ten[exponent];
+      return true;
+    }
+    int remaining_digits =
+        kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
+    if ((0 <= exponent) &&
+        (exponent - remaining_digits < kExactPowersOfTenSize)) {
+      // The trimmed string was short and we can multiply it with
+      // 10^remaining_digits. As a result the remaining exponent now fits
+      // into a double too.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result *= exact_powers_of_ten[remaining_digits];
+      *result *= exact_powers_of_ten[exponent - remaining_digits];
+      return true;
+    }
+  }
+  return false;
+}
+
+
+// Returns 10^exponent as an exact DiyFp.
+// The given exponent must be in the range [1; kDecimalExponentDistance[.
+static DiyFp AdjustmentPowerOfTen(int exponent) {
+  ASSERT(0 < exponent);
+  ASSERT(exponent < PowersOfTenCache::kDecimalExponentDistance);
+  // Simply hardcode the remaining powers for the given decimal exponent
+  // distance.
+  ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
+  switch (exponent) {
+    case 1: return DiyFp(UINT64_2PART_C(0xa0000000, 00000000), -60);
+    case 2: return DiyFp(UINT64_2PART_C(0xc8000000, 00000000), -57);
+    case 3: return DiyFp(UINT64_2PART_C(0xfa000000, 00000000), -54);
+    case 4: return DiyFp(UINT64_2PART_C(0x9c400000, 00000000), -50);
+    case 5: return DiyFp(UINT64_2PART_C(0xc3500000, 00000000), -47);
+    case 6: return DiyFp(UINT64_2PART_C(0xf4240000, 00000000), -44);
+    case 7: return DiyFp(UINT64_2PART_C(0x98968000, 00000000), -40);
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+// If the function returns true then the result is the correct double.
+// Otherwise it is either the correct double or the double that is just below
+// the correct double.
+static bool DiyFpStrtod(Vector<const char> buffer,
+                        int exponent,
+                        double* result) {
+  DiyFp input;
+  int remaining_decimals;
+  ReadDiyFp(buffer, &input, &remaining_decimals);
+  // Since we may have dropped some digits the input is not accurate.
+  // If remaining_decimals is different than 0 than the error is at most
+  // .5 ulp (unit in the last place).
+  // We don't want to deal with fractions and therefore keep a common
+  // denominator.
+  const int kDenominatorLog = 3;
+  const int kDenominator = 1 << kDenominatorLog;
+  // Move the remaining decimals into the exponent.
+  exponent += remaining_decimals;
+  uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
+
+  int old_e = input.e();
+  input.Normalize();
+  error <<= old_e - input.e();
+
+  ASSERT(exponent <= PowersOfTenCache::kMaxDecimalExponent);
+  if (exponent < PowersOfTenCache::kMinDecimalExponent) {
+    *result = 0.0;
+    return true;
+  }
+  DiyFp cached_power;
+  int cached_decimal_exponent;
+  PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
+                                                     &cached_power,
+                                                     &cached_decimal_exponent);
+
+  if (cached_decimal_exponent != exponent) {
+    int adjustment_exponent = exponent - cached_decimal_exponent;
+    DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
+    input.Multiply(adjustment_power);
+    if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
+      // The product of input with the adjustment power fits into a 64 bit
+      // integer.
+      ASSERT(DiyFp::kSignificandSize == 64);
+    } else {
+      // The adjustment power is exact. There is hence only an error of 0.5.
+      error += kDenominator / 2;
+    }
+  }
+
+  input.Multiply(cached_power);
+  // The error introduced by a multiplication of a*b equals
+  //   error_a + error_b + error_a*error_b/2^64 + 0.5
+  // Substituting a with 'input' and b with 'cached_power' we have
+  //   error_b = 0.5  (all cached powers have an error of less than 0.5 ulp),
+  //   error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64
+  int error_b = kDenominator / 2;
+  int error_ab = (error == 0 ? 0 : 1);  // We round up to 1.
+  int fixed_error = kDenominator / 2;
+  error += error_b + error_ab + fixed_error;
+
+  old_e = input.e();
+  input.Normalize();
+  error <<= old_e - input.e();
+
+  // See if the double's significand changes if we add/subtract the error.
+  int order_of_magnitude = DiyFp::kSignificandSize + input.e();
+  int effective_significand_size =
+      Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
+  int precision_digits_count =
+      DiyFp::kSignificandSize - effective_significand_size;
+  if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
+    // This can only happen for very small denormals. In this case the
+    // half-way multiplied by the denominator exceeds the range of an uint64.
+    // Simply shift everything to the right.
+    int shift_amount = (precision_digits_count + kDenominatorLog) -
+        DiyFp::kSignificandSize + 1;
+    input.set_f(input.f() >> shift_amount);
+    input.set_e(input.e() + shift_amount);
+    // We add 1 for the lost precision of error, and kDenominator for
+    // the lost precision of input.f().
+    error = (error >> shift_amount) + 1 + kDenominator;
+    precision_digits_count -= shift_amount;
+  }
+  // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
+  ASSERT(DiyFp::kSignificandSize == 64);
+  ASSERT(precision_digits_count < 64);
+  uint64_t one64 = 1;
+  uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
+  uint64_t precision_bits = input.f() & precision_bits_mask;
+  uint64_t half_way = one64 << (precision_digits_count - 1);
+  precision_bits *= kDenominator;
+  half_way *= kDenominator;
+  DiyFp rounded_input(input.f() >> precision_digits_count,
+                      input.e() + precision_digits_count);
+  if (precision_bits >= half_way + error) {
+    rounded_input.set_f(rounded_input.f() + 1);
+  }
+  // If the last_bits are too close to the half-way case than we are too
+  // inaccurate and round down. In this case we return false so that we can
+  // fall back to a more precise algorithm.
+
+  *result = Double(rounded_input).value();
+  if (half_way - error < precision_bits && precision_bits < half_way + error) {
+    // Too imprecise. The caller will have to fall back to a slower version.
+    // However the returned number is guaranteed to be either the correct
+    // double, or the next-lower double.
+    return false;
+  } else {
+    return true;
+  }
+}
+
+
+// Returns
+//   - -1 if buffer*10^exponent < diy_fp.
+//   -  0 if buffer*10^exponent == diy_fp.
+//   - +1 if buffer*10^exponent > diy_fp.
+// Preconditions:
+//   buffer.length() + exponent <= kMaxDecimalPower + 1
+//   buffer.length() + exponent > kMinDecimalPower
+//   buffer.length() <= kMaxDecimalSignificantDigits
+static int CompareBufferWithDiyFp(Vector<const char> buffer,
+                                  int exponent,
+                                  DiyFp diy_fp) {
+  ASSERT(buffer.length() + exponent <= kMaxDecimalPower + 1);
+  ASSERT(buffer.length() + exponent > kMinDecimalPower);
+  ASSERT(buffer.length() <= kMaxSignificantDecimalDigits);
+  // Make sure that the Bignum will be able to hold all our numbers.
+  // Our Bignum implementation has a separate field for exponents. Shifts will
+  // consume at most one bigit (< 64 bits).
+  // ln(10) == 3.3219...
+  ASSERT(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
+  Bignum buffer_bignum;
+  Bignum diy_fp_bignum;
+  buffer_bignum.AssignDecimalString(buffer);
+  diy_fp_bignum.AssignUInt64(diy_fp.f());
+  if (exponent >= 0) {
+    buffer_bignum.MultiplyByPowerOfTen(exponent);
+  } else {
+    diy_fp_bignum.MultiplyByPowerOfTen(-exponent);
+  }
+  if (diy_fp.e() > 0) {
+    diy_fp_bignum.ShiftLeft(diy_fp.e());
+  } else {
+    buffer_bignum.ShiftLeft(-diy_fp.e());
+  }
+  return Bignum::Compare(buffer_bignum, diy_fp_bignum);
+}
+
+
+// Returns true if the guess is the correct double.
+// Returns false, when guess is either correct or the next-lower double.
+static bool ComputeGuess(Vector<const char> trimmed, int exponent,
+                         double* guess) {
+  if (trimmed.length() == 0) {
+    *guess = 0.0;
+    return true;
+  }
+  if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) {
+    *guess = Double::Infinity();
+    return true;
+  }
+  if (exponent + trimmed.length() <= kMinDecimalPower) {
+    *guess = 0.0;
+    return true;
+  }
+
+  if (DoubleStrtod(trimmed, exponent, guess) ||
+      DiyFpStrtod(trimmed, exponent, guess)) {
+    return true;
+  }
+  if (*guess == Double::Infinity()) {
+    return true;
+  }
+  return false;
+}
+
+double Strtod(Vector<const char> buffer, int exponent) {
+  char copy_buffer[kMaxSignificantDecimalDigits];
+  Vector<const char> trimmed;
+  int updated_exponent;
+  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
+             &trimmed, &updated_exponent);
+  exponent = updated_exponent;
+
+  double guess;
+  bool is_correct = ComputeGuess(trimmed, exponent, &guess);
+  if (is_correct) return guess;
+
+  DiyFp upper_boundary = Double(guess).UpperBoundary();
+  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
+  if (comparison < 0) {
+    return guess;
+  } else if (comparison > 0) {
+    return Double(guess).NextDouble();
+  } else if ((Double(guess).Significand() & 1) == 0) {
+    // Round towards even.
+    return guess;
+  } else {
+    return Double(guess).NextDouble();
+  }
+}
+
+float Strtof(Vector<const char> buffer, int exponent) {
+  char copy_buffer[kMaxSignificantDecimalDigits];
+  Vector<const char> trimmed;
+  int updated_exponent;
+  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
+             &trimmed, &updated_exponent);
+  exponent = updated_exponent;
+
+  double double_guess;
+  bool is_correct = ComputeGuess(trimmed, exponent, &double_guess);
+
+  float float_guess = static_cast<float>(double_guess);
+  if (float_guess == double_guess) {
+    // This shortcut triggers for integer values.
+    return float_guess;
+  }
+
+  // We must catch double-rounding. Say the double has been rounded up, and is
+  // now a boundary of a float, and rounds up again. This is why we have to
+  // look at previous too.
+  // Example (in decimal numbers):
+  //    input: 12349
+  //    high-precision (4 digits): 1235
+  //    low-precision (3 digits):
+  //       when read from input: 123
+  //       when rounded from high precision: 124.
+  // To do this we simply look at the neigbors of the correct result and see
+  // if they would round to the same float. If the guess is not correct we have
+  // to look at four values (since two different doubles could be the correct
+  // double).
+
+  double double_next = Double(double_guess).NextDouble();
+  double double_previous = Double(double_guess).PreviousDouble();
+
+  float f1 = static_cast<float>(double_previous);
+  float f2 = float_guess;
+  float f3 = static_cast<float>(double_next);
+  float f4;
+  if (is_correct) {
+    f4 = f3;
+  } else {
+    double double_next2 = Double(double_next).NextDouble();
+    f4 = static_cast<float>(double_next2);
+  }
+  (void) f2;  // Mark variable as used.
+  ASSERT(f1 <= f2 && f2 <= f3 && f3 <= f4);
+
+  // If the guess doesn't lie near a single-precision boundary we can simply
+  // return its float-value.
+  if (f1 == f4) {
+    return float_guess;
+  }
+
+  ASSERT((f1 != f2 && f2 == f3 && f3 == f4) ||
+         (f1 == f2 && f2 != f3 && f3 == f4) ||
+         (f1 == f2 && f2 == f3 && f3 != f4));
+
+  // guess and next are the two possible canditates (in the same way that
+  // double_guess was the lower candidate for a double-precision guess).
+  float guess = f1;
+  float next = f4;
+  DiyFp upper_boundary;
+  if (guess == 0.0f) {
+    float min_float = 1e-45f;
+    upper_boundary = Double(static_cast<double>(min_float) / 2).AsDiyFp();
+  } else {
+    upper_boundary = Single(guess).UpperBoundary();
+  }
+  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
+  if (comparison < 0) {
+    return guess;
+  } else if (comparison > 0) {
+    return next;
+  } else if ((Single(guess).Significand() & 1) == 0) {
+    // Round towards even.
+    return guess;
+  } else {
+    return next;
+  }
+}
+
+}  // namespace double_conversion
+
+// ICU PATCH: Close ICU namespace
+U_NAMESPACE_END
+#endif // ICU PATCH: close #if !UCONFIG_NO_FORMATTING
diff --git a/deps/icu-small/source/i18n/double-conversion-strtod.h b/deps/icu-small/source/i18n/double-conversion-strtod.h
new file mode 100644
index 00000000000000..e2d6d3c2fe5d7d
--- /dev/null
+++ b/deps/icu-small/source/i18n/double-conversion-strtod.h
@@ -0,0 +1,63 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+//
+// From the double-conversion library. Original license:
+//
+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ICU PATCH: ifdef around UCONFIG_NO_FORMATTING
+#include "unicode/utypes.h"
+#if !UCONFIG_NO_FORMATTING
+
+#ifndef DOUBLE_CONVERSION_STRTOD_H_
+#define DOUBLE_CONVERSION_STRTOD_H_
+
+// ICU PATCH: Customize header file paths for ICU.
+
+#include "double-conversion-utils.h"
+
+// ICU PATCH: Wrap in ICU namespace
+U_NAMESPACE_BEGIN
+
+namespace double_conversion {
+
+// The buffer must only contain digits in the range [0-9]. It must not
+// contain a dot or a sign. It must not start with '0', and must not be empty.
+double Strtod(Vector<const char> buffer, int exponent);
+
+// The buffer must only contain digits in the range [0-9]. It must not
+// contain a dot or a sign. It must not start with '0', and must not be empty.
+float Strtof(Vector<const char> buffer, int exponent);
+
+}  // namespace double_conversion
+
+// ICU PATCH: Close ICU namespace
+U_NAMESPACE_END
+
+#endif  // DOUBLE_CONVERSION_STRTOD_H_
+#endif // ICU PATCH: close #if !UCONFIG_NO_FORMATTING
diff --git a/deps/icu-small/source/i18n/double-conversion-utils.h b/deps/icu-small/source/i18n/double-conversion-utils.h
index 02795b4bc565ae..57fc49b231a3a0 100644
--- a/deps/icu-small/source/i18n/double-conversion-utils.h
+++ b/deps/icu-small/source/i18n/double-conversion-utils.h
@@ -75,9 +75,9 @@ inline void abort_noreturn() { abort(); }
 // the output of the division with the expected result. (Inlining must be
 // disabled.)
 // On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
-// ICU PATCH: Enable ARM builds for Windows with 'defined(_M_ARM)'.
+// ICU PATCH: Enable ARM32 & ARM64 builds for Windows with 'defined(_M_ARM) || defined(_M_ARM64)'.
 #if defined(_M_X64) || defined(__x86_64__) || \
-    defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || \
+    defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
     defined(__hppa__) || defined(__ia64__) || \
     defined(__mips__) || \
     defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
diff --git a/deps/icu-small/source/i18n/double-conversion.cpp b/deps/icu-small/source/i18n/double-conversion.cpp
index 8629284aa0e0f5..570a05bc42946c 100644
--- a/deps/icu-small/source/i18n/double-conversion.cpp
+++ b/deps/icu-small/source/i18n/double-conversion.cpp
@@ -38,13 +38,14 @@
 #include <math.h>
 
 // ICU PATCH: Customize header file paths for ICU.
-// The files fixed-dtoa.h and strtod.h are not needed.
+// The file fixed-dtoa.h is not needed.
 
 #include "double-conversion.h"
 
 #include "double-conversion-bignum-dtoa.h"
 #include "double-conversion-fast-dtoa.h"
 #include "double-conversion-ieee.h"
+#include "double-conversion-strtod.h"
 #include "double-conversion-utils.h"
 
 // ICU PATCH: Wrap in ICU namespace
@@ -431,7 +432,6 @@ void DoubleToStringConverter::DoubleToAscii(double v,
 }
 
 
-#if 0 // not needed for ICU
 // Consumes the given substring from the iterator.
 // Returns false, if the substring does not match.
 template <class Iterator>
@@ -469,6 +469,7 @@ static const uc16 kWhitespaceTable16[] = {
 static const int kWhitespaceTable16Length = ARRAY_SIZE(kWhitespaceTable16);
 
 
+
 static bool isWhitespace(int x) {
   if (x < 128) {
     for (int i = 0; i < kWhitespaceTable7Length; i++) {
@@ -647,7 +648,6 @@ static double RadixStringToIeee(Iterator* current,
   return Double(DiyFp(number, exponent)).value();
 }
 
-
 template <class Iterator>
 double StringToDoubleConverter::StringToIeee(
     Iterator input,
@@ -996,7 +996,6 @@ float StringToDoubleConverter::StringToFloat(
   return static_cast<float>(StringToIeee(buffer, length, false,
                                          processed_characters_count));
 }
-#endif // not needed for ICU
 
 }  // namespace double_conversion
 
diff --git a/deps/icu-small/source/i18n/double-conversion.h b/deps/icu-small/source/i18n/double-conversion.h
index 0939412734a6bb..200537a360a7cc 100644
--- a/deps/icu-small/source/i18n/double-conversion.h
+++ b/deps/icu-small/source/i18n/double-conversion.h
@@ -391,6 +391,7 @@ class DoubleToStringConverter {
   const int decimal_in_shortest_high_;
   const int max_leading_padding_zeroes_in_precision_mode_;
   const int max_trailing_padding_zeroes_in_precision_mode_;
+#endif // not needed for ICU
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
 };
@@ -554,7 +555,6 @@ class StringToDoubleConverter {
                       int* processed_characters_count) const;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
-#endif // not needed for ICU
 };
 
 }  // namespace double_conversion
diff --git a/deps/icu-small/source/i18n/fmtable.cpp b/deps/icu-small/source/i18n/fmtable.cpp
index 73f9b66ab6f950..cb6134cb4b2423 100644
--- a/deps/icu-small/source/i18n/fmtable.cpp
+++ b/deps/icu-small/source/i18n/fmtable.cpp
@@ -19,6 +19,7 @@
 
 #if !UCONFIG_NO_FORMATTING
 
+#include <cstdlib>
 #include <math.h>
 #include "unicode/fmtable.h"
 #include "unicode/ustring.h"
@@ -28,9 +29,8 @@
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
-#include "decNumber.h"
-#include "digitlst.h"
 #include "fmtableimp.h"
+#include "number_decimalquantity.h"
 
 // *****************************************************************************
 // class Formattable
@@ -40,6 +40,8 @@ U_NAMESPACE_BEGIN
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Formattable)
 
+using number::impl::DecimalQuantity;
+
 
 //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
 
@@ -103,7 +105,7 @@ void  Formattable::init() {
     fValue.fInt64 = 0;
     fType = kLong;
     fDecimalStr = NULL;
-    fDecimalNum = NULL;
+    fDecimalQuantity = NULL;
     fBogus.setToBogus();
 }
 
@@ -257,8 +259,8 @@ Formattable::operator=(const Formattable& source)
         }
 
         UErrorCode status = U_ZERO_ERROR;
-        if (source.fDecimalNum != NULL) {
-          fDecimalNum = new DigitList(*source.fDecimalNum); // TODO: use internal digit list
+        if (source.fDecimalQuantity != NULL) {
+          fDecimalQuantity = new DecimalQuantity(*source.fDecimalQuantity);
         }
         if (source.fDecimalStr != NULL) {
             fDecimalStr = new CharString(*source.fDecimalStr, status);
@@ -357,13 +359,8 @@ void Formattable::dispose()
     delete fDecimalStr;
     fDecimalStr = NULL;
 
-    FmtStackData *stackData = (FmtStackData*)fStackData;
-    if(fDecimalNum != &(stackData->stackDecimalNum)) {
-      delete fDecimalNum;
-    } else {
-      fDecimalNum->~DigitList(); // destruct, don't deallocate
-    }
-    fDecimalNum = NULL;
+    delete fDecimalQuantity;
+    fDecimalQuantity = NULL;
 }
 
 Formattable *
@@ -465,13 +462,13 @@ Formattable::getInt64(UErrorCode& status) const
         } else if (fValue.fDouble < (double)U_INT64_MIN) {
             status = U_INVALID_FORMAT_ERROR;
             return U_INT64_MIN;
-        } else if (fabs(fValue.fDouble) > U_DOUBLE_MAX_EXACT_INT && fDecimalNum != NULL) {
-            int64_t val = fDecimalNum->getInt64();
-            if (val != 0) {
-                return val;
+        } else if (fabs(fValue.fDouble) > U_DOUBLE_MAX_EXACT_INT && fDecimalQuantity != NULL) {
+            if (fDecimalQuantity->fitsInLong(true)) {
+                return fDecimalQuantity->toLong();
             } else {
+                // Unexpected
                 status = U_INVALID_FORMAT_ERROR;
-                return fValue.fDouble > 0 ? U_INT64_MAX : U_INT64_MIN;
+                return fDecimalQuantity->isNegative() ? U_INT64_MIN : U_INT64_MAX;
             }
         } else {
             return (int64_t)fValue.fDouble;
@@ -714,84 +711,85 @@ StringPiece Formattable::getDecimalNumber(UErrorCode &status) {
 
 CharString *Formattable::internalGetCharString(UErrorCode &status) {
     if(fDecimalStr == NULL) {
-      if (fDecimalNum == NULL) {
+      if (fDecimalQuantity == NULL) {
         // No decimal number for the formattable yet.  Which means the value was
         // set directly by the user as an int, int64 or double.  If the value came
         // from parsing, or from the user setting a decimal number, fDecimalNum
         // would already be set.
         //
-        fDecimalNum = new DigitList; // TODO: use internal digit list
-        if (fDecimalNum == NULL) {
-          status = U_MEMORY_ALLOCATION_ERROR;
-          return NULL;
-        }
-
-        switch (fType) {
-        case kDouble:
-          fDecimalNum->set(this->getDouble());
-          break;
-        case kLong:
-          fDecimalNum->set(this->getLong());
-          break;
-        case kInt64:
-          fDecimalNum->set(this->getInt64());
-          break;
-        default:
-          // The formattable's value is not a numeric type.
-          status = U_INVALID_STATE_ERROR;
-          return NULL;
-        }
+        LocalPointer<DecimalQuantity> dq(new DecimalQuantity(), status);
+        if (U_FAILURE(status)) { return nullptr; }
+        populateDecimalQuantity(*dq, status);
+        if (U_FAILURE(status)) { return nullptr; }
+        fDecimalQuantity = dq.orphan();
       }
 
-      fDecimalStr = new CharString;
+      fDecimalStr = new CharString();
       if (fDecimalStr == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return NULL;
       }
-      fDecimalNum->getDecimal(*fDecimalStr, status);
+      // Older ICUs called uprv_decNumberToString here, which is not exactly the same as
+      // DecimalQuantity::toScientificString(). The biggest difference is that uprv_decNumberToString does
+      // not print scientific notation for magnitudes greater than -5 and smaller than some amount (+5?).
+      if (fDecimalQuantity->isZero()) {
+        fDecimalStr->append("0", -1, status);
+      } else if (std::abs(fDecimalQuantity->getMagnitude()) < 5) {
+        fDecimalStr->appendInvariantChars(fDecimalQuantity->toPlainString(), status);
+      } else {
+        fDecimalStr->appendInvariantChars(fDecimalQuantity->toScientificString(), status);
+      }
     }
     return fDecimalStr;
 }
 
+void
+Formattable::populateDecimalQuantity(number::impl::DecimalQuantity& output, UErrorCode& status) const {
+    if (fDecimalQuantity != nullptr) {
+        output = *fDecimalQuantity;
+        return;
+    }
 
-DigitList *
-Formattable::getInternalDigitList() {
-  FmtStackData *stackData = (FmtStackData*)fStackData;
-  if(fDecimalNum != &(stackData->stackDecimalNum)) {
-    delete fDecimalNum;
-    fDecimalNum = new (&(stackData->stackDecimalNum), kOnStack) DigitList();
-  } else {
-    fDecimalNum->clear();
-  }
-  return fDecimalNum;
+    switch (fType) {
+        case kDouble:
+            output.setToDouble(this->getDouble());
+            output.roundToInfinity();
+            break;
+        case kLong:
+            output.setToInt(this->getLong());
+            break;
+        case kInt64:
+            output.setToLong(this->getInt64());
+            break;
+        default:
+            // The formattable's value is not a numeric type.
+            status = U_INVALID_STATE_ERROR;
+    }
 }
 
 // ---------------------------------------
 void
-Formattable::adoptDigitList(DigitList *dl) {
-  if(fDecimalNum==dl) {
-    fDecimalNum = NULL; // don't delete
-  }
-  dispose();
-
-  fDecimalNum = dl;
-
-  if(dl==NULL) { // allow adoptDigitList(NULL) to clear
-    return;
-  }
+Formattable::adoptDecimalQuantity(DecimalQuantity *dq) {
+    if (fDecimalQuantity != NULL) {
+        delete fDecimalQuantity;
+    }
+    fDecimalQuantity = dq;
+    if (dq == NULL) { // allow adoptDigitList(NULL) to clear
+        return;
+    }
 
     // Set the value into the Union of simple type values.
-    // Cannot use the set() functions because they would delete the fDecimalNum value,
-
-    if (fDecimalNum->fitsIntoLong(FALSE)) {
-        fType = kLong;
-        fValue.fInt64 = fDecimalNum->getLong();
-    } else if (fDecimalNum->fitsIntoInt64(FALSE)) {
-        fType = kInt64;
-        fValue.fInt64 = fDecimalNum->getInt64();
+    // Cannot use the set() functions because they would delete the fDecimalNum value.
+    if (fDecimalQuantity->fitsInLong()) {
+        fValue.fInt64 = fDecimalQuantity->toLong();
+        if (fValue.fInt64 <= INT32_MAX && fValue.fInt64 >= INT32_MIN) {
+            fType = kLong;
+        } else {
+            fType = kInt64;
+        }
     } else {
         fType = kDouble;
-        fValue.fDouble = fDecimalNum->getDouble();
+        fValue.fDouble = fDecimalQuantity->toDouble();
     }
 }
 
@@ -804,24 +802,12 @@ Formattable::setDecimalNumber(StringPiece numberString, UErrorCode &status) {
     }
     dispose();
 
-    // Copy the input string and nul-terminate it.
-    //    The decNumber library requires nul-terminated input.  StringPiece input
-    //    is not guaranteed nul-terminated.  Too bad.
-    //    CharString automatically adds the nul.
-    DigitList *dnum = new DigitList(); // TODO: use getInternalDigitList
-    if (dnum == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return;
-    }
-    dnum->set(CharString(numberString, status).toStringPiece(), status);
-    if (U_FAILURE(status)) {
-        delete dnum;
-        return;   // String didn't contain a decimal number.
-    }
-    adoptDigitList(dnum);
+    auto* dq = new DecimalQuantity();
+    dq->setToDecNumber(numberString, status);
+    adoptDecimalQuantity(dq);
 
     // Note that we do not hang on to the caller's input string.
-    // If we are asked for the string, we will regenerate one from fDecimalNum.
+    // If we are asked for the string, we will regenerate one from fDecimalQuantity.
 }
 
 #if 0
diff --git a/deps/icu-small/source/i18n/fmtableimp.h b/deps/icu-small/source/i18n/fmtableimp.h
index 0e6ccd24da7f02..78b7caff548e82 100644
--- a/deps/icu-small/source/i18n/fmtableimp.h
+++ b/deps/icu-small/source/i18n/fmtableimp.h
@@ -10,22 +10,12 @@
 #ifndef FMTABLEIMP_H
 #define FMTABLEIMP_H
 
-#include "digitlst.h"
+#include "number_decimalquantity.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 U_NAMESPACE_BEGIN
 
-/**
- * @internal
- */
-struct FmtStackData {
-  DigitList stackDecimalNum;   // 128
-  //CharString stackDecimalStr;  // 64
-  //                         -----
-  //                         192 total
-};
-
 /**
  * Maximum int64_t value that can be stored in a double without chancing losing precision.
  *   IEEE doubles have 53 bits of mantissa, 10 bits exponent, 1 bit sign.
diff --git a/deps/icu-small/source/i18n/fphdlimp.cpp b/deps/icu-small/source/i18n/fphdlimp.cpp
index abcec97ee3171c..c4015fae1bbaff 100644
--- a/deps/icu-small/source/i18n/fphdlimp.cpp
+++ b/deps/icu-small/source/i18n/fphdlimp.cpp
@@ -22,17 +22,8 @@ U_NAMESPACE_BEGIN
 FieldPositionHandler::~FieldPositionHandler() {
 }
 
-void
-FieldPositionHandler::addAttribute(int32_t, int32_t, int32_t) {
-}
-
-void
-FieldPositionHandler::shiftLast(int32_t) {
-}
-
-UBool
-FieldPositionHandler::isRecording(void) const {
-  return FALSE;
+void FieldPositionHandler::setShift(int32_t delta) {
+  fShift = delta;
 }
 
 
@@ -48,8 +39,8 @@ FieldPositionOnlyHandler::~FieldPositionOnlyHandler() {
 void
 FieldPositionOnlyHandler::addAttribute(int32_t id, int32_t start, int32_t limit) {
   if (pos.getField() == id) {
-    pos.setBeginIndex(start);
-    pos.setEndIndex(limit);
+    pos.setBeginIndex(start + fShift);
+    pos.setEndIndex(limit + fShift);
   }
 }
 
@@ -91,8 +82,8 @@ FieldPositionIteratorHandler::addAttribute(int32_t id, int32_t start, int32_t li
   if (iter && U_SUCCESS(status) && start < limit) {
     int32_t size = vec->size();
     vec->addElement(id, status);
-    vec->addElement(start, status);
-    vec->addElement(limit, status);
+    vec->addElement(start + fShift, status);
+    vec->addElement(limit + fShift, status);
     if (!U_SUCCESS(status)) {
       vec->setSize(size);
     }
diff --git a/deps/icu-small/source/i18n/fphdlimp.h b/deps/icu-small/source/i18n/fphdlimp.h
index f3ac12c2bacb9a..2e9d5622b1b5b0 100644
--- a/deps/icu-small/source/i18n/fphdlimp.h
+++ b/deps/icu-small/source/i18n/fphdlimp.h
@@ -22,11 +22,16 @@ U_NAMESPACE_BEGIN
 // base class, null implementation
 
 class U_I18N_API FieldPositionHandler: public UMemory {
+ protected:
+  int32_t fShift = 0;
+
  public:
   virtual ~FieldPositionHandler();
-  virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
-  virtual void shiftLast(int32_t delta);
-  virtual UBool isRecording(void) const;
+  virtual void addAttribute(int32_t id, int32_t start, int32_t limit) = 0;
+  virtual void shiftLast(int32_t delta) = 0;
+  virtual UBool isRecording(void) const = 0;
+
+  void setShift(int32_t delta);
 };
 
 
@@ -39,9 +44,9 @@ class FieldPositionOnlyHandler : public FieldPositionHandler {
   FieldPositionOnlyHandler(FieldPosition& pos);
   virtual ~FieldPositionOnlyHandler();
 
-  virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
-  virtual void shiftLast(int32_t delta);
-  virtual UBool isRecording(void) const;
+  void addAttribute(int32_t id, int32_t start, int32_t limit) U_OVERRIDE;
+  void shiftLast(int32_t delta) U_OVERRIDE;
+  UBool isRecording(void) const U_OVERRIDE;
 };
 
 
@@ -63,9 +68,9 @@ class FieldPositionIteratorHandler : public FieldPositionHandler {
   FieldPositionIteratorHandler(FieldPositionIterator* posIter, UErrorCode& status);
   ~FieldPositionIteratorHandler();
 
-  virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
-  virtual void shiftLast(int32_t delta);
-  virtual UBool isRecording(void) const;
+  void addAttribute(int32_t id, int32_t start, int32_t limit) U_OVERRIDE;
+  void shiftLast(int32_t delta) U_OVERRIDE;
+  UBool isRecording(void) const U_OVERRIDE;
 };
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/measunit.cpp b/deps/icu-small/source/i18n/measunit.cpp
index e21afcba029e04..dc156aa720aae0 100644
--- a/deps/icu-small/source/i18n/measunit.cpp
+++ b/deps/icu-small/source/i18n/measunit.cpp
@@ -41,21 +41,21 @@ static const int32_t gOffsets[] = {
     16,
     20,
     24,
-    285,
-    295,
-    306,
-    310,
-    316,
-    320,
-    340,
-    341,
+    321,
+    331,
+    342,
+    346,
     352,
-    355,
-    361,
-    366,
-    370,
-    374,
-    399
+    356,
+    376,
+    377,
+    388,
+    391,
+    397,
+    402,
+    406,
+    410,
+    435
 };
 
 static const int32_t gIndexes[] = {
@@ -136,15 +136,18 @@ static const char * const gSubTypes[] = {
     "AED",
     "AFA",
     "AFN",
+    "ALK",
     "ALL",
     "AMD",
     "ANG",
     "AOA",
+    "AOK",
     "AON",
     "AOR",
     "ARA",
     "ARP",
     "ARS",
+    "ARY",
     "ATS",
     "AUD",
     "AWG",
@@ -158,6 +161,8 @@ static const char * const gSubTypes[] = {
     "BEC",
     "BEF",
     "BEL",
+    "BGJ",
+    "BGK",
     "BGL",
     "BGN",
     "BHD",
@@ -165,7 +170,9 @@ static const char * const gSubTypes[] = {
     "BMD",
     "BND",
     "BOB",
+    "BOP",
     "BOV",
+    "BRB",
     "BRC",
     "BRE",
     "BRL",
@@ -173,6 +180,7 @@ static const char * const gSubTypes[] = {
     "BRR",
     "BSD",
     "BTN",
+    "BUK",
     "BWP",
     "BYB",
     "BYN",
@@ -191,6 +199,7 @@ static const char * const gSubTypes[] = {
     "COU",
     "CRC",
     "CSD",
+    "CSJ",
     "CSK",
     "CUC",
     "CUP",
@@ -225,10 +234,13 @@ static const char * const gSubTypes[] = {
     "GHS",
     "GIP",
     "GMD",
+    "GNE",
     "GNF",
+    "GNS",
     "GQE",
     "GRD",
     "GTQ",
+    "GWE",
     "GWP",
     "GYD",
     "HKD",
@@ -239,10 +251,13 @@ static const char * const gSubTypes[] = {
     "HUF",
     "IDR",
     "IEP",
+    "ILP",
+    "ILR",
     "ILS",
     "INR",
     "IQD",
     "IRR",
+    "ISJ",
     "ISK",
     "ITL",
     "JMD",
@@ -257,11 +272,13 @@ static const char * const gSubTypes[] = {
     "KWD",
     "KYD",
     "KZT",
+    "LAJ",
     "LAK",
     "LBP",
     "LKR",
     "LRD",
     "LSL",
+    "LSM",
     "LTL",
     "LTT",
     "LUC",
@@ -280,17 +297,23 @@ static const char * const gSubTypes[] = {
     "MNT",
     "MOP",
     "MRO",
+    "MRU",
     "MTL",
+    "MTP",
     "MUR",
+    "MVQ",
     "MVR",
     "MWK",
     "MXN",
+    "MXP",
     "MXV",
     "MYR",
+    "MZE",
     "MZM",
     "MZN",
     "NAD",
     "NGN",
+    "NIC",
     "NIO",
     "NLG",
     "NOK",
@@ -298,6 +321,7 @@ static const char * const gSubTypes[] = {
     "NZD",
     "OMR",
     "PAB",
+    "PEH",
     "PEI",
     "PEN",
     "PES",
@@ -309,6 +333,8 @@ static const char * const gSubTypes[] = {
     "PTE",
     "PYG",
     "QAR",
+    "RHD",
+    "ROK",
     "ROL",
     "RON",
     "RSD",
@@ -320,6 +346,7 @@ static const char * const gSubTypes[] = {
     "SCR",
     "SDD",
     "SDG",
+    "SDP",
     "SEK",
     "SGD",
     "SHP",
@@ -331,6 +358,8 @@ static const char * const gSubTypes[] = {
     "SRG",
     "SSP",
     "STD",
+    "STN",
+    "SUR",
     "SVC",
     "SYP",
     "SZL",
@@ -349,15 +378,20 @@ static const char * const gSubTypes[] = {
     "TZS",
     "UAH",
     "UAK",
+    "UGS",
+    "UGW",
     "UGX",
     "USD",
     "USN",
     "USS",
     "UYI",
+    "UYN",
+    "UYP",
     "UYU",
     "UZS",
     "VEB",
     "VEF",
+    "VNC",
     "VND",
     "VUV",
     "WST",
@@ -381,6 +415,7 @@ static const char * const gSubTypes[] = {
     "XXX",
     "YDD",
     "YER",
+    "YUD",
     "YUM",
     "YUN",
     "ZAL",
@@ -389,6 +424,7 @@ static const char * const gSubTypes[] = {
     "ZMW",
     "ZRN",
     "ZRZ",
+    "ZWC",
     "ZWD",
     "ZWL",
     "ZWN",
@@ -511,16 +547,20 @@ static const char * const gSubTypes[] = {
 
 // Must be sorted by first value and then second value.
 static int32_t unitPerUnitToSingleUnit[][4] = {
-        {327, 297, 17, 0},
-        {329, 303, 17, 2},
-        {331, 297, 17, 3},
-        {331, 388, 4, 2},
-        {331, 389, 4, 3},
-        {346, 386, 3, 1},
-        {349, 11, 16, 4},
-        {391, 327, 4, 1}
+        {363, 333, 17, 0},
+        {365, 339, 17, 2},
+        {367, 333, 17, 3},
+        {367, 424, 4, 2},
+        {367, 425, 4, 3},
+        {382, 422, 3, 1},
+        {385, 11, 16, 4},
+        {427, 363, 4, 1}
 };
 
+// Shortcuts to the base unit in order to make the default constructor fast
+static const int32_t kBaseTypeIdx = 14;
+static const int32_t kBaseSubTypeIdx = 0;
+
 MeasureUnit *MeasureUnit::createGForce(UErrorCode &status) {
     return MeasureUnit::create(0, 0, status);
 }
@@ -1082,7 +1122,8 @@ static int32_t binarySearch(
 
 MeasureUnit::MeasureUnit() {
     fCurrency[0] = 0;
-    initNoUnit("base");
+    fTypeId = kBaseTypeIdx;
+    fSubTypeId = kBaseSubTypeIdx;
 }
 
 MeasureUnit::MeasureUnit(const MeasureUnit &other)
diff --git a/deps/icu-small/source/i18n/msgfmt.cpp b/deps/icu-small/source/i18n/msgfmt.cpp
index 064585665ae5e6..8b3807e67148a4 100644
--- a/deps/icu-small/source/i18n/msgfmt.cpp
+++ b/deps/icu-small/source/i18n/msgfmt.cpp
@@ -31,6 +31,7 @@
 #include "unicode/decimfmt.h"
 #include "unicode/localpointer.h"
 #include "unicode/msgfmt.h"
+#include "unicode/numberformatter.h"
 #include "unicode/plurfmt.h"
 #include "unicode/rbnf.h"
 #include "unicode/selfmt.h"
@@ -48,7 +49,7 @@
 #include "ustrfmt.h"
 #include "util.h"
 #include "uvector.h"
-#include "visibledigits.h"
+#include "number_decimalquantity.h"
 
 // *****************************************************************************
 // class MessageFormat
@@ -1700,12 +1701,21 @@ Format* MessageFormat::createAppropriateFormat(UnicodeString& type, UnicodeStrin
             formattableType = Formattable::kLong;
             fmt = createIntegerFormat(fLocale, ec);
             break;
-        default: // pattern
-            fmt = NumberFormat::createInstance(fLocale, ec);
-            if (fmt) {
-                DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(fmt);
-                if (decfmt != NULL) {
-                    decfmt->applyPattern(style,parseError,ec);
+        default: // pattern or skeleton
+            int32_t i = 0;
+            for (; PatternProps::isWhiteSpace(style.charAt(i)); i++);
+            if (style.compare(i, 2, u"::", 0, 2) == 0) {
+                // Skeleton
+                UnicodeString skeleton = style.tempSubString(i + 2);
+                fmt = number::NumberFormatter::forSkeleton(skeleton, ec).locale(fLocale).toFormat(ec);
+            } else {
+                // Pattern
+                fmt = NumberFormat::createInstance(fLocale, ec);
+                if (fmt) {
+                    auto* decfmt = dynamic_cast<DecimalFormat*>(fmt);
+                    if (decfmt != nullptr) {
+                        decfmt->applyPattern(style, parseError, ec);
+                    }
                 }
             }
             break;
@@ -1959,14 +1969,14 @@ UnicodeString MessageFormat::PluralSelectorProvider::select(void *ctx, double nu
         return UnicodeString(FALSE, OTHER_STRING, 5);
     }
     context.formatter->format(context.number, context.numberString, ec);
-    const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(context.formatter);
+    auto* decFmt = dynamic_cast<const DecimalFormat *>(context.formatter);
     if(decFmt != NULL) {
-        VisibleDigitsWithExponent digits;
-        decFmt->initVisibleDigitsWithExponent(context.number, digits, ec);
+        number::impl::DecimalQuantity dq;
+        decFmt->formatToDecimalQuantity(context.number, dq, ec);
         if (U_FAILURE(ec)) {
             return UnicodeString(FALSE, OTHER_STRING, 5);
         }
-        return rules->select(digits);
+        return rules->select(dq);
     } else {
         return rules->select(number);
     }
diff --git a/deps/icu-small/source/i18n/nfsubs.cpp b/deps/icu-small/source/i18n/nfsubs.cpp
index ea817453d87c18..3733f0ca74d3e3 100644
--- a/deps/icu-small/source/i18n/nfsubs.cpp
+++ b/deps/icu-small/source/i18n/nfsubs.cpp
@@ -19,8 +19,9 @@
 #include "utypeinfo.h"  // for 'typeid' to work
 
 #include "nfsubs.h"
-#include "digitlst.h"
 #include "fmtableimp.h"
+#include "putilimp.h"
+#include "number_decimalquantity.h"
 
 #if U_HAVE_RBNF
 
@@ -47,6 +48,8 @@ static const UChar gGreaterGreaterThan[] =
 
 U_NAMESPACE_BEGIN
 
+using number::impl::DecimalQuantity;
+
 class SameValueSubstitution : public NFSubstitution {
 public:
     SameValueSubstitution(int32_t pos,
@@ -1069,13 +1072,12 @@ FractionalPartSubstitution::doSubstitution(double number, UnicodeString& toInser
     //              numberToFormat /= 10;
     //          }
 
-    DigitList dl;
-    dl.set(number);
-    dl.roundFixedPoint(20);     // round to 20 fraction digits.
-    dl.reduce();                // Removes any trailing zeros.
+    DecimalQuantity dl;
+    dl.setToDouble(number);
+    dl.roundToMagnitude(-20, UNUM_ROUND_HALFEVEN, status);     // round to 20 fraction digits.
 
     UBool pad = FALSE;
-    for (int32_t didx = dl.getCount()-1; didx>=dl.getDecimalAt(); didx--) {
+    for (int32_t didx = dl.getLowerDisplayMagnitude(); didx<0; didx++) {
       // Loop iterates over fraction digits, starting with the LSD.
       //   include both real digits from the number, and zeros
       //   to the left of the MSD but to the right of the decimal point.
@@ -1084,7 +1086,7 @@ FractionalPartSubstitution::doSubstitution(double number, UnicodeString& toInser
       } else {
         pad = TRUE;
       }
-      int64_t digit = didx>=0 ? dl.getDigit(didx) - '0' : 0;
+      int64_t digit = dl.getDigit(didx);
       getRuleSet()->format(digit, toInsertInto, _pos + getPos(), recursionCount, status);
     }
 
@@ -1142,7 +1144,8 @@ FractionalPartSubstitution::doParse(const UnicodeString& text,
         int32_t digit;
 //          double p10 = 0.1;
 
-        DigitList dl;
+        DecimalQuantity dl;
+        int32_t totalDigits = 0;
         NumberFormat* fmt = NULL;
         while (workText.length() > 0 && workPos.getIndex() != 0) {
             workPos.setIndex(0);
@@ -1170,7 +1173,8 @@ FractionalPartSubstitution::doParse(const UnicodeString& text,
             }
 
             if (workPos.getIndex() != 0) {
-                dl.append((char)('0' + digit));
+                dl.appendDigit(static_cast<int8_t>(digit), 0, true);
+                totalDigits++;
 //                  result += digit * p10;
 //                  p10 /= 10;
                 parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex());
@@ -1183,7 +1187,8 @@ FractionalPartSubstitution::doParse(const UnicodeString& text,
         }
         delete fmt;
 
-        result = dl.getCount() == 0 ? 0 : dl.getDouble();
+        dl.adjustMagnitude(-totalDigits);
+        result = dl.toDouble();
         result = composeRuleValue(result, baseValue);
         resVal.setDouble(result);
         return TRUE;
diff --git a/deps/icu-small/source/i18n/number_affixutils.cpp b/deps/icu-small/source/i18n/number_affixutils.cpp
index df4b267af5a004..8da29a03d52d56 100644
--- a/deps/icu-small/source/i18n/number_affixutils.cpp
+++ b/deps/icu-small/source/i18n/number_affixutils.cpp
@@ -3,21 +3,25 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "number_affixutils.h"
 #include "unicode/utf16.h"
+#include "unicode/uniset.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
-int32_t AffixUtils::estimateLength(const CharSequence &patternString, UErrorCode &status) {
+TokenConsumer::~TokenConsumer() = default;
+SymbolProvider::~SymbolProvider() = default;
+
+int32_t AffixUtils::estimateLength(const UnicodeString &patternString, UErrorCode &status) {
     AffixPatternState state = STATE_BASE;
     int32_t offset = 0;
     int32_t length = 0;
     for (; offset < patternString.length();) {
-        UChar32 cp = patternString.codePointAt(offset);
+        UChar32 cp = patternString.char32At(offset);
 
         switch (state) {
             case STATE_BASE:
@@ -78,12 +82,12 @@ int32_t AffixUtils::estimateLength(const CharSequence &patternString, UErrorCode
     return length;
 }
 
-UnicodeString AffixUtils::escape(const CharSequence &input) {
+UnicodeString AffixUtils::escape(const UnicodeString &input) {
     AffixPatternState state = STATE_BASE;
     int32_t offset = 0;
     UnicodeString output;
     for (; offset < input.length();) {
-        UChar32 cp = input.codePointAt(offset);
+        UChar32 cp = input.char32At(offset);
 
         switch (cp) {
             case u'\'':
@@ -153,7 +157,7 @@ Field AffixUtils::getFieldForType(AffixPatternType type) {
 }
 
 int32_t
-AffixUtils::unescape(const CharSequence &affixPattern, NumberStringBuilder &output, int32_t position,
+AffixUtils::unescape(const UnicodeString &affixPattern, NumberStringBuilder &output, int32_t position,
                      const SymbolProvider &provider, UErrorCode &status) {
     int32_t length = 0;
     AffixTag tag;
@@ -173,7 +177,7 @@ AffixUtils::unescape(const CharSequence &affixPattern, NumberStringBuilder &outp
     return length;
 }
 
-int32_t AffixUtils::unescapedCodePointCount(const CharSequence &affixPattern,
+int32_t AffixUtils::unescapedCodePointCount(const UnicodeString &affixPattern,
                                             const SymbolProvider &provider, UErrorCode &status) {
     int32_t length = 0;
     AffixTag tag;
@@ -192,7 +196,7 @@ int32_t AffixUtils::unescapedCodePointCount(const CharSequence &affixPattern,
 }
 
 bool
-AffixUtils::containsType(const CharSequence &affixPattern, AffixPatternType type, UErrorCode &status) {
+AffixUtils::containsType(const UnicodeString &affixPattern, AffixPatternType type, UErrorCode &status) {
     if (affixPattern.length() == 0) {
         return false;
     }
@@ -207,7 +211,7 @@ AffixUtils::containsType(const CharSequence &affixPattern, AffixPatternType type
     return false;
 }
 
-bool AffixUtils::hasCurrencySymbols(const CharSequence &affixPattern, UErrorCode &status) {
+bool AffixUtils::hasCurrencySymbols(const UnicodeString &affixPattern, UErrorCode &status) {
     if (affixPattern.length() == 0) {
         return false;
     }
@@ -222,9 +226,9 @@ bool AffixUtils::hasCurrencySymbols(const CharSequence &affixPattern, UErrorCode
     return false;
 }
 
-UnicodeString AffixUtils::replaceType(const CharSequence &affixPattern, AffixPatternType type,
+UnicodeString AffixUtils::replaceType(const UnicodeString &affixPattern, AffixPatternType type,
                                       char16_t replacementChar, UErrorCode &status) {
-    UnicodeString output = affixPattern.toUnicodeString();
+    UnicodeString output(affixPattern); // copy
     if (affixPattern.length() == 0) {
         return output;
     };
@@ -239,11 +243,41 @@ UnicodeString AffixUtils::replaceType(const CharSequence &affixPattern, AffixPat
     return output;
 }
 
-AffixTag AffixUtils::nextToken(AffixTag tag, const CharSequence &patternString, UErrorCode &status) {
+bool AffixUtils::containsOnlySymbolsAndIgnorables(const UnicodeString& affixPattern,
+                                                  const UnicodeSet& ignorables, UErrorCode& status) {
+    if (affixPattern.length() == 0) {
+        return true;
+    };
+    AffixTag tag;
+    while (hasNext(tag, affixPattern)) {
+        tag = nextToken(tag, affixPattern, status);
+        if (U_FAILURE(status)) { return false; }
+        if (tag.type == TYPE_CODEPOINT && !ignorables.contains(tag.codePoint)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void AffixUtils::iterateWithConsumer(const UnicodeString& affixPattern, TokenConsumer& consumer,
+                                     UErrorCode& status) {
+    if (affixPattern.length() == 0) {
+        return;
+    };
+    AffixTag tag;
+    while (hasNext(tag, affixPattern)) {
+        tag = nextToken(tag, affixPattern, status);
+        if (U_FAILURE(status)) { return; }
+        consumer.consumeToken(tag.type, tag.codePoint, status);
+        if (U_FAILURE(status)) { return; }
+    }
+}
+
+AffixTag AffixUtils::nextToken(AffixTag tag, const UnicodeString &patternString, UErrorCode &status) {
     int32_t offset = tag.offset;
     int32_t state = tag.state;
     for (; offset < patternString.length();) {
-        UChar32 cp = patternString.codePointAt(offset);
+        UChar32 cp = patternString.char32At(offset);
         int32_t count = U16_LENGTH(cp);
 
         switch (state) {
@@ -382,7 +416,7 @@ AffixTag AffixUtils::nextToken(AffixTag tag, const CharSequence &patternString,
     }
 }
 
-bool AffixUtils::hasNext(const AffixTag &tag, const CharSequence &string) {
+bool AffixUtils::hasNext(const AffixTag &tag, const UnicodeString &string) {
     // First check for the {-1} and default initializer syntax.
     if (tag.offset < 0) {
         return false;
diff --git a/deps/icu-small/source/i18n/number_affixutils.h b/deps/icu-small/source/i18n/number_affixutils.h
index fd76c99b975566..1d7e1a115e046a 100644
--- a/deps/icu-small/source/i18n/number_affixutils.h
+++ b/deps/icu-small/source/i18n/number_affixutils.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_AFFIXUTILS_H__
 #define __NUMBER_AFFIXUTILS_H__
 
@@ -12,6 +12,7 @@
 #include "unicode/stringpiece.h"
 #include "unicode/unistr.h"
 #include "number_stringbuilder.h"
+#include "unicode/uniset.h"
 
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
@@ -37,19 +38,27 @@ struct AffixTag {
     AffixPatternState state;
     AffixPatternType type;
 
-    AffixTag() : offset(0), state(STATE_BASE) {}
+    AffixTag()
+            : offset(0), state(STATE_BASE) {}
 
-    AffixTag(int32_t offset) : offset(offset) {}
+    AffixTag(int32_t offset)
+            : offset(offset) {}
 
     AffixTag(int32_t offset, UChar32 codePoint, AffixPatternState state, AffixPatternType type)
-        : offset(offset), codePoint(codePoint), state(state), type(type)
-        {}
+            : offset(offset), codePoint(codePoint), state(state), type(type) {}
+};
+
+class TokenConsumer {
+  public:
+    virtual ~TokenConsumer();
+
+    virtual void consumeToken(AffixPatternType type, UChar32 cp, UErrorCode& status) = 0;
 };
 
 // Exported as U_I18N_API because it is a base class for other exported types
 class U_I18N_API SymbolProvider {
   public:
-    virtual ~SymbolProvider() = default;
+    virtual ~SymbolProvider();
 
     // TODO: Could this be more efficient if it returned by reference?
     virtual UnicodeString getSymbol(AffixPatternType type) const = 0;
@@ -107,7 +116,7 @@ class U_I18N_API AffixUtils {
      * @param patternString The original string whose width will be estimated.
      * @return The length of the unescaped string.
      */
-    static int32_t estimateLength(const CharSequence &patternString, UErrorCode &status);
+    static int32_t estimateLength(const UnicodeString& patternString, UErrorCode& status);
 
     /**
      * Takes a string and escapes (quotes) characters that have special meaning in the affix pattern
@@ -118,7 +127,7 @@ class U_I18N_API AffixUtils {
      * @param input The string to be escaped.
      * @return The resulting UnicodeString.
      */
-    static UnicodeString escape(const CharSequence &input);
+    static UnicodeString escape(const UnicodeString& input);
 
     static Field getFieldForType(AffixPatternType type);
 
@@ -134,9 +143,8 @@ class U_I18N_API AffixUtils {
      * @param position The index into the NumberStringBuilder to insert the string.
      * @param provider An object to generate locale symbols.
      */
-    static int32_t
-    unescape(const CharSequence &affixPattern, NumberStringBuilder &output, int32_t position,
-             const SymbolProvider &provider, UErrorCode &status);
+    static int32_t unescape(const UnicodeString& affixPattern, NumberStringBuilder& output,
+                            int32_t position, const SymbolProvider& provider, UErrorCode& status);
 
     /**
    * Sames as {@link #unescape}, but only calculates the code point count.  More efficient than {@link #unescape}
@@ -146,8 +154,8 @@ class U_I18N_API AffixUtils {
      * @param provider An object to generate locale symbols.
      * @return The same return value as if you called {@link #unescape}.
      */
-    static int32_t unescapedCodePointCount(const CharSequence &affixPattern,
-                                           const SymbolProvider &provider, UErrorCode &status);
+    static int32_t unescapedCodePointCount(const UnicodeString& affixPattern,
+                                           const SymbolProvider& provider, UErrorCode& status);
 
     /**
      * Checks whether the given affix pattern contains at least one token of the given type, which is
@@ -157,8 +165,7 @@ class U_I18N_API AffixUtils {
      * @param type The token type.
      * @return true if the affix pattern contains the given token type; false otherwise.
      */
-    static bool
-    containsType(const CharSequence &affixPattern, AffixPatternType type, UErrorCode &status);
+    static bool containsType(const UnicodeString& affixPattern, AffixPatternType type, UErrorCode& status);
 
     /**
      * Checks whether the specified affix pattern has any unquoted currency symbols ("¤").
@@ -166,7 +173,7 @@ class U_I18N_API AffixUtils {
      * @param affixPattern The string to check for currency symbols.
      * @return true if the literal has at least one unquoted currency symbol; false otherwise.
      */
-    static bool hasCurrencySymbols(const CharSequence &affixPattern, UErrorCode &status);
+    static bool hasCurrencySymbols(const UnicodeString& affixPattern, UErrorCode& status);
 
     /**
      * Replaces all occurrences of tokens with the given type with the given replacement char.
@@ -176,9 +183,21 @@ class U_I18N_API AffixUtils {
      * @param replacementChar The char to substitute in place of chars of the given token type.
      * @return A string containing the new affix pattern.
      */
-    static UnicodeString
-    replaceType(const CharSequence &affixPattern, AffixPatternType type, char16_t replacementChar,
-                UErrorCode &status);
+    static UnicodeString replaceType(const UnicodeString& affixPattern, AffixPatternType type,
+                                     char16_t replacementChar, UErrorCode& status);
+
+    /**
+     * Returns whether the given affix pattern contains only symbols and ignorables as defined by the
+     * given ignorables set.
+     */
+    static bool containsOnlySymbolsAndIgnorables(const UnicodeString& affixPattern,
+                                                 const UnicodeSet& ignorables, UErrorCode& status);
+
+    /**
+     * Iterates over the affix pattern, calling the TokenConsumer for each token.
+     */
+    static void iterateWithConsumer(const UnicodeString& affixPattern, TokenConsumer& consumer,
+                                    UErrorCode& status);
 
     /**
      * Returns the next token from the affix pattern.
@@ -190,7 +209,7 @@ class U_I18N_API AffixUtils {
      *     (never negative), or -1 if there were no more tokens in the affix pattern.
      * @see #hasNext
      */
-    static AffixTag nextToken(AffixTag tag, const CharSequence &patternString, UErrorCode &status);
+    static AffixTag nextToken(AffixTag tag, const UnicodeString& patternString, UErrorCode& status);
 
     /**
      * Returns whether the affix pattern string has any more tokens to be retrieved from a call to
@@ -200,7 +219,7 @@ class U_I18N_API AffixUtils {
      * @param string The affix pattern.
      * @return true if there are more tokens to consume; false otherwise.
      */
-    static bool hasNext(const AffixTag &tag, const CharSequence &string);
+    static bool hasNext(const AffixTag& tag, const UnicodeString& string);
 
   private:
     /**
@@ -208,8 +227,8 @@ class U_I18N_API AffixUtils {
      * The order of the arguments is consistent with Java, but the order of the stored
      * fields is not necessarily the same.
      */
-    static inline AffixTag
-    makeTag(int32_t offset, AffixPatternType type, AffixPatternState state, UChar32 cp) {
+    static inline AffixTag makeTag(int32_t offset, AffixPatternType type, AffixPatternState state,
+                                   UChar32 cp) {
         return {offset, cp, state, type};
     }
 };
diff --git a/deps/icu-small/source/i18n/number_asformat.cpp b/deps/icu-small/source/i18n/number_asformat.cpp
new file mode 100644
index 00000000000000..c6bb538932cec8
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_asformat.cpp
@@ -0,0 +1,105 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include <stdlib.h>
+#include <cmath>
+#include "number_asformat.h"
+#include "number_types.h"
+#include "number_utils.h"
+#include "fphdlimp.h"
+#include "number_utypes.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LocalizedNumberFormatterAsFormat)
+
+LocalizedNumberFormatterAsFormat::LocalizedNumberFormatterAsFormat(
+        const LocalizedNumberFormatter& formatter, const Locale& locale)
+        : fFormatter(formatter), fLocale(locale) {
+    const char* localeName = locale.getName();
+    setLocaleIDs(localeName, localeName);
+}
+
+LocalizedNumberFormatterAsFormat::~LocalizedNumberFormatterAsFormat() = default;
+
+UBool LocalizedNumberFormatterAsFormat::operator==(const Format& other) const {
+    auto* _other = dynamic_cast<const LocalizedNumberFormatterAsFormat*>(&other);
+    if (_other == nullptr) {
+        return false;
+    }
+    // TODO: Change this to use LocalizedNumberFormatter::operator== if it is ever proposed.
+    // This implementation is fine, but not particularly efficient.
+    UErrorCode localStatus = U_ZERO_ERROR;
+    return fFormatter.toSkeleton(localStatus) == _other->fFormatter.toSkeleton(localStatus);
+}
+
+Format* LocalizedNumberFormatterAsFormat::clone() const {
+    return new LocalizedNumberFormatterAsFormat(*this);
+}
+
+UnicodeString& LocalizedNumberFormatterAsFormat::format(const Formattable& obj, UnicodeString& appendTo,
+                                                        FieldPosition& pos, UErrorCode& status) const {
+    if (U_FAILURE(status)) { return appendTo; }
+    UFormattedNumberData data;
+    obj.populateDecimalQuantity(data.quantity, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    fFormatter.formatImpl(&data, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    // always return first occurrence:
+    pos.setBeginIndex(0);
+    pos.setEndIndex(0);
+    bool found = data.string.nextFieldPosition(pos, status);
+    if (found && appendTo.length() != 0) {
+        pos.setBeginIndex(pos.getBeginIndex() + appendTo.length());
+        pos.setEndIndex(pos.getEndIndex() + appendTo.length());
+    }
+    appendTo.append(data.string.toTempUnicodeString());
+    return appendTo;
+}
+
+UnicodeString& LocalizedNumberFormatterAsFormat::format(const Formattable& obj, UnicodeString& appendTo,
+                                                        FieldPositionIterator* posIter,
+                                                        UErrorCode& status) const {
+    if (U_FAILURE(status)) { return appendTo; }
+    UFormattedNumberData data;
+    obj.populateDecimalQuantity(data.quantity, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    fFormatter.formatImpl(&data, status);
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    appendTo.append(data.string.toTempUnicodeString());
+    if (posIter != nullptr) {
+        FieldPositionIteratorHandler fpih(posIter, status);
+        data.string.getAllFieldPositions(fpih, status);
+    }
+    return appendTo;
+}
+
+void LocalizedNumberFormatterAsFormat::parseObject(const UnicodeString&, Formattable&,
+                                                   ParsePosition& parse_pos) const {
+    // Not supported.
+    parse_pos.setErrorIndex(0);
+}
+
+const LocalizedNumberFormatter& LocalizedNumberFormatterAsFormat::getNumberFormatter() const {
+    return fFormatter;
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_asformat.h b/deps/icu-small/source/i18n/number_asformat.h
new file mode 100644
index 00000000000000..bf82d72ae302a4
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_asformat.h
@@ -0,0 +1,107 @@
+// © 2017 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMBER_ASFORMAT_H__
+#define __NUMBER_ASFORMAT_H__
+
+#include "unicode/numberformatter.h"
+#include "number_types.h"
+#include "number_decimalquantity.h"
+#include "number_scientific.h"
+#include "number_patternstring.h"
+#include "number_modifiers.h"
+#include "number_multiplier.h"
+#include "number_roundingutils.h"
+#include "decNumber.h"
+#include "charstr.h"
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+/**
+ * A wrapper around LocalizedNumberFormatter implementing the Format interface, enabling improved
+ * compatibility with other APIs.
+ *
+ * @draft ICU 62
+ * @see NumberFormatter
+ */
+class U_I18N_API LocalizedNumberFormatterAsFormat : public Format {
+  public:
+    LocalizedNumberFormatterAsFormat(const LocalizedNumberFormatter& formatter, const Locale& locale);
+
+    /**
+     * Destructor.
+     */
+    ~LocalizedNumberFormatterAsFormat() U_OVERRIDE;
+
+    /**
+     * Equals operator.
+     */
+    UBool operator==(const Format& other) const U_OVERRIDE;
+
+    /**
+     * Creates a copy of this object.
+     */
+    Format* clone() const U_OVERRIDE;
+
+    /**
+     * Formats a Number using the wrapped LocalizedNumberFormatter. The provided formattable must be a
+     * number type.
+     */
+    UnicodeString& format(const Formattable& obj, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+
+    /**
+     * Formats a Number using the wrapped LocalizedNumberFormatter. The provided formattable must be a
+     * number type.
+     */
+    UnicodeString& format(const Formattable& obj, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
+
+    /**
+     * Not supported: sets an error index and returns.
+     */
+    void parseObject(const UnicodeString& source, Formattable& result,
+                     ParsePosition& parse_pos) const U_OVERRIDE;
+
+    /**
+     * Gets the LocalizedNumberFormatter that this wrapper class uses to format numbers.
+     *
+     * For maximum efficiency, this function returns by const reference. You must copy the return value
+     * into a local variable if you want to use it beyond the lifetime of the current object:
+     *
+     * <pre>
+     * LocalizedNumberFormatter localFormatter = fmt->getNumberFormatter();
+     * </pre>
+     *
+     * You can however use the return value directly when chaining:
+     *
+     * <pre>
+     * FormattedNumber result = fmt->getNumberFormatter().formatDouble(514.23, status);
+     * </pre>
+     *
+     * @return The unwrapped LocalizedNumberFormatter.
+     */
+    const LocalizedNumberFormatter& getNumberFormatter() const;
+
+    UClassID getDynamicClassID() const U_OVERRIDE;
+    static UClassID U_EXPORT2 getStaticClassID();
+
+  private:
+    LocalizedNumberFormatter fFormatter;
+
+    // Even though the locale is inside the LocalizedNumberFormatter, we have to keep it here, too, because
+    // LocalizedNumberFormatter doesn't have a getLocale() method, and ICU-TC didn't want to add one.
+    Locale fLocale;
+};
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif // __NUMBER_ASFORMAT_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_capi.cpp b/deps/icu-small/source/i18n/number_capi.cpp
new file mode 100644
index 00000000000000..37ad8bd76fcd72
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_capi.cpp
@@ -0,0 +1,213 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "fphdlimp.h"
+#include "number_utypes.h"
+#include "numparse_types.h"
+#include "unicode/numberformatter.h"
+#include "unicode/unumberformatter.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+
+//////////////////////////////////
+/// C API CONVERSION FUNCTIONS ///
+//////////////////////////////////
+
+UNumberFormatterData* UNumberFormatterData::validate(UNumberFormatter* input, UErrorCode& status) {
+    auto* constInput = static_cast<const UNumberFormatter*>(input);
+    auto* validated = validate(constInput, status);
+    return const_cast<UNumberFormatterData*>(validated);
+}
+
+const UNumberFormatterData*
+UNumberFormatterData::validate(const UNumberFormatter* input, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    if (input == nullptr) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return nullptr;
+    }
+    auto* impl = reinterpret_cast<const UNumberFormatterData*>(input);
+    if (impl->fMagic != UNumberFormatterData::kMagic) {
+        status = U_INVALID_FORMAT_ERROR;
+        return nullptr;
+    }
+    return impl;
+}
+
+UNumberFormatter* UNumberFormatterData::exportForC() {
+    return reinterpret_cast<UNumberFormatter*>(this);
+}
+
+UFormattedNumberData* UFormattedNumberData::validate(UFormattedNumber* input, UErrorCode& status) {
+    auto* constInput = static_cast<const UFormattedNumber*>(input);
+    auto* validated = validate(constInput, status);
+    return const_cast<UFormattedNumberData*>(validated);
+}
+
+const UFormattedNumberData*
+UFormattedNumberData::validate(const UFormattedNumber* input, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return nullptr;
+    }
+    if (input == nullptr) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return nullptr;
+    }
+    auto* impl = reinterpret_cast<const UFormattedNumberData*>(input);
+    if (impl->fMagic != UFormattedNumberData::kMagic) {
+        status = U_INVALID_FORMAT_ERROR;
+        return nullptr;
+    }
+    return impl;
+}
+
+UFormattedNumber* UFormattedNumberData::exportForC() {
+    return reinterpret_cast<UFormattedNumber*>(this);
+}
+
+/////////////////////////////////////
+/// END CAPI CONVERSION FUNCTIONS ///
+/////////////////////////////////////
+
+
+U_CAPI UNumberFormatter* U_EXPORT2
+unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const char* locale,
+                               UErrorCode* ec) {
+    auto* impl = new UNumberFormatterData();
+    if (impl == nullptr) {
+        *ec = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    // Readonly-alias constructor (first argument is whether we are NUL-terminated)
+    UnicodeString skeletonString(skeletonLen == -1, skeleton, skeletonLen);
+    impl->fFormatter = NumberFormatter::forSkeleton(skeletonString, *ec).locale(locale);
+    return impl->exportForC();
+}
+
+U_CAPI UFormattedNumber* U_EXPORT2
+unumf_openResult(UErrorCode* ec) {
+    auto* impl = new UFormattedNumberData();
+    if (impl == nullptr) {
+        *ec = U_MEMORY_ALLOCATION_ERROR;
+        return nullptr;
+    }
+    return impl->exportForC();
+}
+
+U_CAPI void U_EXPORT2
+unumf_formatInt(const UNumberFormatter* uformatter, int64_t value, UFormattedNumber* uresult,
+                UErrorCode* ec) {
+    const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec);
+    UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    result->string.clear();
+    result->quantity.setToLong(value);
+    formatter->fFormatter.formatImpl(result, *ec);
+}
+
+U_CAPI void U_EXPORT2
+unumf_formatDouble(const UNumberFormatter* uformatter, double value, UFormattedNumber* uresult,
+                   UErrorCode* ec) {
+    const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec);
+    UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    result->string.clear();
+    result->quantity.setToDouble(value);
+    formatter->fFormatter.formatImpl(result, *ec);
+}
+
+U_CAPI void U_EXPORT2
+unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32_t valueLen,
+                    UFormattedNumber* uresult, UErrorCode* ec) {
+    const UNumberFormatterData* formatter = UNumberFormatterData::validate(uformatter, *ec);
+    UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    result->string.clear();
+    result->quantity.setToDecNumber({value, valueLen}, *ec);
+    if (U_FAILURE(*ec)) { return; }
+    formatter->fFormatter.formatImpl(result, *ec);
+}
+
+U_CAPI int32_t U_EXPORT2
+unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t bufferCapacity,
+                     UErrorCode* ec) {
+    const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return 0; }
+
+    if (buffer == nullptr ? bufferCapacity != 0 : bufferCapacity < 0) {
+        *ec = U_ILLEGAL_ARGUMENT_ERROR;
+        return 0;
+    }
+
+    return result->string.toTempUnicodeString().extract(buffer, bufferCapacity, *ec);
+}
+
+U_CAPI UBool U_EXPORT2
+unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* ufpos, UErrorCode* ec) {
+    const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return FALSE; }
+
+    if (ufpos == nullptr) {
+        *ec = U_ILLEGAL_ARGUMENT_ERROR;
+        return FALSE;
+    }
+
+    FieldPosition fp;
+    fp.setField(ufpos->field);
+    fp.setBeginIndex(ufpos->beginIndex);
+    fp.setEndIndex(ufpos->endIndex);
+    bool retval = result->string.nextFieldPosition(fp, *ec);
+    ufpos->beginIndex = fp.getBeginIndex();
+    ufpos->endIndex = fp.getEndIndex();
+    // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
+    return retval ? TRUE : FALSE;
+}
+
+U_CAPI void U_EXPORT2
+unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPositionIterator* ufpositer,
+                                 UErrorCode* ec) {
+    const UFormattedNumberData* result = UFormattedNumberData::validate(uresult, *ec);
+    if (U_FAILURE(*ec)) { return; }
+
+    if (ufpositer == nullptr) {
+        *ec = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+
+    auto* fpi = reinterpret_cast<FieldPositionIterator*>(ufpositer);
+    FieldPositionIteratorHandler fpih(fpi, *ec);
+    result->string.getAllFieldPositions(fpih, *ec);
+}
+
+U_CAPI void U_EXPORT2
+unumf_closeResult(UFormattedNumber* uresult) {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    const UFormattedNumberData* impl = UFormattedNumberData::validate(uresult, localStatus);
+    delete impl;
+}
+
+U_CAPI void U_EXPORT2
+unumf_close(UNumberFormatter* f) {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    const UNumberFormatterData* impl = UNumberFormatterData::validate(f, localStatus);
+    delete impl;
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_compact.cpp b/deps/icu-small/source/i18n/number_compact.cpp
index cc0d8fd2a20cce..40278e1a012e54 100644
--- a/deps/icu-small/source/i18n/number_compact.cpp
+++ b/deps/icu-small/source/i18n/number_compact.cpp
@@ -3,14 +3,15 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
-#include "resource.h"
-#include "number_compact.h"
 #include "unicode/ustring.h"
 #include "unicode/ures.h"
 #include "cstring.h"
 #include "charstr.h"
+#include "resource.h"
+#include "number_compact.h"
+#include "number_microprops.h"
 #include "uresimp.h"
 
 using namespace icu;
@@ -275,15 +276,15 @@ void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micr
     int magnitude;
     if (quantity.isZero()) {
         magnitude = 0;
-        micros.rounding.apply(quantity, status);
+        micros.rounder.apply(quantity, status);
     } else {
         // TODO: Revisit chooseMultiplierAndApply
-        int multiplier = micros.rounding.chooseMultiplierAndApply(quantity, data, status);
+        int multiplier = micros.rounder.chooseMultiplierAndApply(quantity, data, status);
         magnitude = quantity.isZero() ? 0 : quantity.getMagnitude();
         magnitude -= multiplier;
     }
 
-    StandardPlural::Form plural = quantity.getStandardPlural(rules);
+    StandardPlural::Form plural = utils::getStandardPlural(rules, quantity);
     const UChar *patternString = data.getPattern(magnitude, plural);
     if (patternString == nullptr) {
         // Use the default (non-compact) modifier.
@@ -313,7 +314,7 @@ void CompactHandler::processQuantity(DecimalQuantity &quantity, MicroProps &micr
     }
 
     // We already performed rounding. Do not perform it again.
-    micros.rounding = Rounder::constructPassThrough();
+    micros.rounder = RoundingImpl::passThrough();
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_compact.h b/deps/icu-small/source/i18n/number_compact.h
index f7adf36416e92f..dda5f9f9b2dc91 100644
--- a/deps/icu-small/source/i18n/number_compact.h
+++ b/deps/icu-small/source/i18n/number_compact.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_COMPACT_H__
 #define __NUMBER_COMPACT_H__
 
diff --git a/deps/icu-small/source/i18n/number_currencysymbols.cpp b/deps/icu-small/source/i18n/number_currencysymbols.cpp
new file mode 100644
index 00000000000000..0b79d6596f18c0
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_currencysymbols.cpp
@@ -0,0 +1,123 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "number_currencysymbols.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+
+CurrencySymbols::CurrencySymbols(CurrencyUnit currency, const Locale& locale, UErrorCode& status)
+        : fCurrency(currency), fLocaleName(locale.getName(), status) {
+    fCurrencySymbol.setToBogus();
+    fIntlCurrencySymbol.setToBogus();
+}
+
+CurrencySymbols::CurrencySymbols(CurrencyUnit currency, const Locale& locale,
+                                 const DecimalFormatSymbols& symbols, UErrorCode& status)
+        : CurrencySymbols(currency, locale, status) {
+    // If either of the overrides is present, save it in the local UnicodeString.
+    if (symbols.isCustomCurrencySymbol()) {
+        fCurrencySymbol = symbols.getConstSymbol(DecimalFormatSymbols::kCurrencySymbol);
+    }
+    if (symbols.isCustomIntlCurrencySymbol()) {
+        fIntlCurrencySymbol = symbols.getConstSymbol(DecimalFormatSymbols::kIntlCurrencySymbol);
+    }
+}
+
+const char16_t* CurrencySymbols::getIsoCode() const {
+    return fCurrency.getISOCurrency();
+}
+
+UnicodeString CurrencySymbols::getNarrowCurrencySymbol(UErrorCode& status) const {
+    // Note: currently no override is available for narrow currency symbol
+    return loadSymbol(UCURR_NARROW_SYMBOL_NAME, status);
+}
+
+UnicodeString CurrencySymbols::getCurrencySymbol(UErrorCode& status) const {
+    if (!fCurrencySymbol.isBogus()) {
+        return fCurrencySymbol;
+    }
+    return loadSymbol(UCURR_SYMBOL_NAME, status);
+}
+
+UnicodeString CurrencySymbols::loadSymbol(UCurrNameStyle selector, UErrorCode& status) const {
+    const char16_t* isoCode = fCurrency.getISOCurrency();
+    UBool ignoredIsChoiceFormatFillIn = FALSE;
+    int32_t symbolLen = 0;
+    const char16_t* symbol = ucurr_getName(
+            isoCode,
+            fLocaleName.data(),
+            selector,
+            &ignoredIsChoiceFormatFillIn,
+            &symbolLen,
+            &status);
+    // If given an unknown currency, ucurr_getName returns the input string, which we can't alias safely!
+    // Otherwise, symbol points to a resource bundle, and we can use readonly-aliasing constructor.
+    if (symbol == isoCode) {
+        return UnicodeString(isoCode, 3);
+    } else {
+        return UnicodeString(TRUE, symbol, symbolLen);
+    }
+}
+
+UnicodeString CurrencySymbols::getIntlCurrencySymbol(UErrorCode&) const {
+    if (!fIntlCurrencySymbol.isBogus()) {
+        return fIntlCurrencySymbol;
+    }
+    // Note: Not safe to use readonly-aliasing constructor here because the buffer belongs to this object,
+    // which could be destructed or moved during the lifetime of the return value.
+    return UnicodeString(fCurrency.getISOCurrency(), 3);
+}
+
+UnicodeString CurrencySymbols::getPluralName(StandardPlural::Form plural, UErrorCode& status) const {
+    const char16_t* isoCode = fCurrency.getISOCurrency();
+    UBool isChoiceFormat = FALSE;
+    int32_t symbolLen = 0;
+    const char16_t* symbol = ucurr_getPluralName(
+            isoCode,
+            fLocaleName.data(),
+            &isChoiceFormat,
+            StandardPlural::getKeyword(plural),
+            &symbolLen,
+            &status);
+    // If given an unknown currency, ucurr_getName returns the input string, which we can't alias safely!
+    // Otherwise, symbol points to a resource bundle, and we can use readonly-aliasing constructor.
+    if (symbol == isoCode) {
+        return UnicodeString(isoCode, 3);
+    } else {
+        return UnicodeString(TRUE, symbol, symbolLen);
+    }
+}
+
+
+CurrencyUnit
+icu::number::impl::resolveCurrency(const DecimalFormatProperties& properties, const Locale& locale,
+                                   UErrorCode& status) {
+    if (!properties.currency.isNull()) {
+        return properties.currency.getNoError();
+    } else {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        char16_t buf[4] = {};
+        ucurr_forLocale(locale.getName(), buf, 4, &localStatus);
+        if (U_SUCCESS(localStatus)) {
+            return CurrencyUnit(buf, status);
+        } else {
+            // Default currency (XXX)
+            return CurrencyUnit();
+        }
+    }
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_currencysymbols.h b/deps/icu-small/source/i18n/number_currencysymbols.h
new file mode 100644
index 00000000000000..9996bf96ae08a1
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_currencysymbols.h
@@ -0,0 +1,65 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMBER_CURRENCYSYMBOLS_H__
+#define __SOURCE_NUMBER_CURRENCYSYMBOLS_H__
+
+#include "numparse_types.h"
+#include "charstr.h"
+#include "number_decimfmtprops.h"
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API CurrencySymbols : public UMemory {
+  public:
+    CurrencySymbols() = default; // default constructor: leaves class in valid but undefined state
+
+    /** Creates an instance in which all symbols are loaded from data. */
+    CurrencySymbols(CurrencyUnit currency, const Locale& locale, UErrorCode& status);
+
+    /** Creates an instance in which some symbols might be pre-populated. */
+    CurrencySymbols(CurrencyUnit currency, const Locale& locale, const DecimalFormatSymbols& symbols,
+                    UErrorCode& status);
+
+    const char16_t* getIsoCode() const;
+
+    UnicodeString getNarrowCurrencySymbol(UErrorCode& status) const;
+
+    UnicodeString getCurrencySymbol(UErrorCode& status) const;
+
+    UnicodeString getIntlCurrencySymbol(UErrorCode& status) const;
+
+    UnicodeString getPluralName(StandardPlural::Form plural, UErrorCode& status) const;
+
+  protected:
+    // Required fields:
+    CurrencyUnit fCurrency;
+    CharString fLocaleName;
+
+    // Optional fields:
+    UnicodeString fCurrencySymbol;
+    UnicodeString fIntlCurrencySymbol;
+
+    UnicodeString loadSymbol(UCurrNameStyle selector, UErrorCode& status) const;
+};
+
+
+/**
+ * Resolves the effective currency from the property bag.
+ */
+CurrencyUnit
+resolveCurrency(const DecimalFormatProperties& properties, const Locale& locale, UErrorCode& status);
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMBER_CURRENCYSYMBOLS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_decimalquantity.cpp b/deps/icu-small/source/i18n/number_decimalquantity.cpp
index b68df26ba26167..9d80e3349cb8aa 100644
--- a/deps/icu-small/source/i18n/number_decimalquantity.cpp
+++ b/deps/icu-small/source/i18n/number_decimalquantity.cpp
@@ -3,25 +3,30 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
-#include "uassert.h"
+#include <cstdlib>
 #include <cmath>
-#include "cmemory.h"
-#include "decNumber.h"
 #include <limits>
+#include <stdlib.h>
+
+#include "unicode/plurrule.h"
+#include "cmemory.h"
+#include "number_decnum.h"
+#include "putilimp.h"
 #include "number_decimalquantity.h"
-#include "decContext.h"
-#include "decNumber.h"
 #include "number_roundingutils.h"
 #include "double-conversion.h"
-#include "unicode/plurrule.h"
+#include "charstr.h"
+#include "number_utils.h"
+#include "uassert.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
 using icu::double_conversion::DoubleToStringConverter;
+using icu::double_conversion::StringToDoubleConverter;
 
 namespace {
 
@@ -29,25 +34,6 @@ int8_t NEGATIVE_FLAG = 1;
 int8_t INFINITY_FLAG = 2;
 int8_t NAN_FLAG = 4;
 
-static constexpr int32_t DEFAULT_DIGITS = 34;
-typedef MaybeStackHeaderAndArray<decNumber, char, DEFAULT_DIGITS> DecNumberWithStorage;
-
-/** Helper function to convert a decNumber-compatible string into a decNumber. */
-void stringToDecNumber(StringPiece n, DecNumberWithStorage &dn) {
-    decContext set;
-    uprv_decContextDefault(&set, DEC_INIT_BASE);
-    uprv_decContextSetRounding(&set, DEC_ROUND_HALF_EVEN);
-    set.traps = 0; // no traps, thank you
-    if (n.length() > DEFAULT_DIGITS) {
-        dn.resize(n.length(), 0);
-        set.digits = n.length();
-    } else {
-        set.digits = DEFAULT_DIGITS;
-    }
-    uprv_decNumberFromString(dn.getAlias(), n.data(), &set);
-    U_ASSERT(DECDPUN == 1);
-}
-
 /** Helper function for safe subtraction (no overflow). */
 inline int32_t safeSubtract(int32_t a, int32_t b) {
     // Note: In C++, signed integer subtraction is undefined behavior.
@@ -83,6 +69,7 @@ static double DOUBLE_MULTIPLIERS[] = {
 
 }  // namespace
 
+icu::IFixedDecimal::~IFixedDecimal() = default;
 
 DecimalQuantity::DecimalQuantity() {
     setBcdToZero();
@@ -101,11 +88,30 @@ DecimalQuantity::DecimalQuantity(const DecimalQuantity &other) {
     *this = other;
 }
 
+DecimalQuantity::DecimalQuantity(DecimalQuantity&& src) U_NOEXCEPT {
+    *this = std::move(src);
+}
+
 DecimalQuantity &DecimalQuantity::operator=(const DecimalQuantity &other) {
     if (this == &other) {
         return *this;
     }
     copyBcdFrom(other);
+    copyFieldsFrom(other);
+    return *this;
+}
+
+DecimalQuantity& DecimalQuantity::operator=(DecimalQuantity&& src) U_NOEXCEPT {
+    if (this == &src) {
+        return *this;
+    }
+    moveBcdFrom(src);
+    copyFieldsFrom(src);
+    return *this;
+}
+
+void DecimalQuantity::copyFieldsFrom(const DecimalQuantity& other) {
+    bogus = other.bogus;
     lOptPos = other.lOptPos;
     lReqPos = other.lReqPos;
     rReqPos = other.rReqPos;
@@ -116,7 +122,6 @@ DecimalQuantity &DecimalQuantity::operator=(const DecimalQuantity &other) {
     origDouble = other.origDouble;
     origDelta = other.origDelta;
     isApproximate = other.isApproximate;
-    return *this;
 }
 
 void DecimalQuantity::clear() {
@@ -129,10 +134,16 @@ void DecimalQuantity::clear() {
 }
 
 void DecimalQuantity::setIntegerLength(int32_t minInt, int32_t maxInt) {
-    // Validation should happen outside of DecimalQuantity, e.g., in the Rounder class.
+    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
     U_ASSERT(minInt >= 0);
     U_ASSERT(maxInt >= minInt);
 
+    // Special behavior: do not set minInt to be less than what is already set.
+    // This is so significant digits rounding can set the integer length.
+    if (minInt < lReqPos) {
+        minInt = lReqPos;
+    }
+
     // Save values into internal state
     // Negation is safe for minFrac/maxFrac because -Integer.MAX_VALUE > Integer.MIN_VALUE
     lOptPos = maxInt;
@@ -140,7 +151,7 @@ void DecimalQuantity::setIntegerLength(int32_t minInt, int32_t maxInt) {
 }
 
 void DecimalQuantity::setFractionLength(int32_t minFrac, int32_t maxFrac) {
-    // Validation should happen outside of DecimalQuantity, e.g., in the Rounder class.
+    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
     U_ASSERT(minFrac >= 0);
     U_ASSERT(maxFrac >= minFrac);
 
@@ -160,29 +171,53 @@ uint64_t DecimalQuantity::getPositionFingerprint() const {
 }
 
 void DecimalQuantity::roundToIncrement(double roundingIncrement, RoundingMode roundingMode,
-                                       int32_t minMaxFrac, UErrorCode& status) {
-    // TODO: This is innefficient.  Improve?
-    // TODO: Should we convert to decNumber instead?
+                                       int32_t maxFrac, UErrorCode& status) {
+    // TODO(13701): This is innefficient.  Improve?
+    // TODO(13701): Should we convert to decNumber instead?
+    roundToInfinity();
     double temp = toDouble();
     temp /= roundingIncrement;
-    setToDouble(temp);
-    roundToMagnitude(0, roundingMode, status);
-    temp = toDouble();
+    // Use another DecimalQuantity to perform the actual rounding...
+    DecimalQuantity dq;
+    dq.setToDouble(temp);
+    dq.roundToMagnitude(0, roundingMode, status);
+    temp = dq.toDouble();
     temp *= roundingIncrement;
     setToDouble(temp);
     // Since we reset the value to a double, we need to specify the rounding boundary
     // in order to get the DecimalQuantity out of approximation mode.
-    roundToMagnitude(-minMaxFrac, roundingMode, status);
+    // NOTE: In Java, we have minMaxFrac, but in C++, the two are differentiated.
+    roundToMagnitude(-maxFrac, roundingMode, status);
 }
 
-void DecimalQuantity::multiplyBy(int32_t multiplicand) {
+void DecimalQuantity::multiplyBy(const DecNum& multiplicand, UErrorCode& status) {
     if (isInfinite() || isZero() || isNaN()) {
         return;
     }
-    // TODO: Should we convert to decNumber instead?
-    double temp = toDouble();
-    temp *= multiplicand;
-    setToDouble(temp);
+    // Convert to DecNum, multiply, and convert back.
+    DecNum decnum;
+    toDecNum(decnum, status);
+    if (U_FAILURE(status)) { return; }
+    decnum.multiplyBy(multiplicand, status);
+    if (U_FAILURE(status)) { return; }
+    setToDecNum(decnum, status);
+}
+
+void DecimalQuantity::divideBy(const DecNum& divisor, UErrorCode& status) {
+    if (isInfinite() || isZero() || isNaN()) {
+        return;
+    }
+    // Convert to DecNum, multiply, and convert back.
+    DecNum decnum;
+    toDecNum(decnum, status);
+    if (U_FAILURE(status)) { return; }
+    decnum.divideBy(divisor, status);
+    if (U_FAILURE(status)) { return; }
+    setToDecNum(decnum, status);
+}
+
+void DecimalQuantity::negate() {
+    flags ^= NEGATIVE_FLAG;
 }
 
 int32_t DecimalQuantity::getMagnitude() const {
@@ -190,21 +225,17 @@ int32_t DecimalQuantity::getMagnitude() const {
     return scale + precision - 1;
 }
 
-void DecimalQuantity::adjustMagnitude(int32_t delta) {
+bool DecimalQuantity::adjustMagnitude(int32_t delta) {
     if (precision != 0) {
-        scale += delta;
-        origDelta += delta;
-    }
-}
-
-StandardPlural::Form DecimalQuantity::getStandardPlural(const PluralRules *rules) const {
-    if (rules == nullptr) {
-        // Fail gracefully if the user didn't provide a PluralRules
-        return StandardPlural::Form::OTHER;
-    } else {
-        UnicodeString ruleString = rules->select(*this);
-        return StandardPlural::orOtherFromString(ruleString);
+        // i.e., scale += delta; origDelta += delta
+        bool overflow = uprv_add32_overflow(scale, delta, &scale);
+        overflow = uprv_add32_overflow(origDelta, delta, &origDelta) || overflow;
+        // Make sure that precision + scale won't overflow, either
+        int32_t dummy;
+        overflow = overflow || uprv_add32_overflow(scale, precision, &dummy);
+        return overflow;
     }
+    return false;
 }
 
 double DecimalQuantity::getPluralOperand(PluralOperand operand) const {
@@ -214,7 +245,8 @@ double DecimalQuantity::getPluralOperand(PluralOperand operand) const {
 
     switch (operand) {
         case PLURAL_OPERAND_I:
-            return static_cast<double>(toLong());
+            // Invert the negative sign if necessary
+            return static_cast<double>(isNegative() ? -toLong(true) : toLong(true));
         case PLURAL_OPERAND_F:
             return static_cast<double>(toFractionLong(true));
         case PLURAL_OPERAND_T:
@@ -228,6 +260,10 @@ double DecimalQuantity::getPluralOperand(PluralOperand operand) const {
     }
 }
 
+bool DecimalQuantity::hasIntegerValue() const {
+    return scale >= 0;
+}
+
 int32_t DecimalQuantity::getUpperDisplayMagnitude() const {
     // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
     // See the comment in the header file explaining the "isApproximate" field.
@@ -287,7 +323,10 @@ bool DecimalQuantity::isZero() const {
 DecimalQuantity &DecimalQuantity::setToInt(int32_t n) {
     setBcdToZero();
     flags = 0;
-    if (n < 0) {
+    if (n == INT32_MIN) {
+        flags |= NEGATIVE_FLAG;
+        // leave as INT32_MIN; handled below in _setToInt()
+    } else if (n < 0) {
         flags |= NEGATIVE_FLAG;
         n = -n;
     }
@@ -309,7 +348,7 @@ void DecimalQuantity::_setToInt(int32_t n) {
 DecimalQuantity &DecimalQuantity::setToLong(int64_t n) {
     setBcdToZero();
     flags = 0;
-    if (n < 0) {
+    if (n < 0 && n > INT64_MIN) {
         flags |= NEGATIVE_FLAG;
         n = -n;
     }
@@ -322,10 +361,12 @@ DecimalQuantity &DecimalQuantity::setToLong(int64_t n) {
 
 void DecimalQuantity::_setToLong(int64_t n) {
     if (n == INT64_MIN) {
-        static const char *int64minStr = "9.223372036854775808E+18";
-        DecNumberWithStorage dn;
-        stringToDecNumber(int64minStr, dn);
-        readDecNumberToBcd(dn.getAlias());
+        DecNum decnum;
+        UErrorCode localStatus = U_ZERO_ERROR;
+        decnum.setTo("9.223372036854775808E+18", localStatus);
+        if (U_FAILURE(localStatus)) { return; } // unexpected
+        flags |= NEGATIVE_FLAG;
+        readDecNumberToBcd(decnum);
     } else if (n <= INT32_MAX) {
         readIntToBcd(static_cast<int32_t>(n));
     } else {
@@ -337,7 +378,7 @@ DecimalQuantity &DecimalQuantity::setToDouble(double n) {
     setBcdToZero();
     flags = 0;
     // signbit() from <math.h> handles +0.0 vs -0.0
-    if (std::signbit(n) != 0) {
+    if (std::signbit(n)) {
         flags |= NEGATIVE_FLAG;
         n = -n;
     }
@@ -424,51 +465,107 @@ void DecimalQuantity::convertToAccurateDouble() {
     explicitExactDouble = true;
 }
 
-DecimalQuantity &DecimalQuantity::setToDecNumber(StringPiece n) {
+DecimalQuantity &DecimalQuantity::setToDecNumber(StringPiece n, UErrorCode& status) {
     setBcdToZero();
     flags = 0;
 
-    DecNumberWithStorage dn;
-    stringToDecNumber(n, dn);
+    // Compute the decNumber representation
+    DecNum decnum;
+    decnum.setTo(n, status);
 
-    // The code path for decNumber is modeled after BigDecimal in Java.
-    if (decNumberIsNegative(dn.getAlias())) {
-        flags |= NEGATIVE_FLAG;
-    }
-    if (!decNumberIsZero(dn.getAlias())) {
-        _setToDecNumber(dn.getAlias());
-    }
+    _setToDecNum(decnum, status);
     return *this;
 }
 
-void DecimalQuantity::_setToDecNumber(decNumber *n) {
-    // Java fastpaths for ints here. In C++, just always read directly from the decNumber.
-    readDecNumberToBcd(n);
-    compact();
+DecimalQuantity& DecimalQuantity::setToDecNum(const DecNum& decnum, UErrorCode& status) {
+    setBcdToZero();
+    flags = 0;
+
+    _setToDecNum(decnum, status);
+    return *this;
 }
 
-int64_t DecimalQuantity::toLong() const {
-    int64_t result = 0L;
-    for (int32_t magnitude = scale + precision - 1; magnitude >= 0; magnitude--) {
+void DecimalQuantity::_setToDecNum(const DecNum& decnum, UErrorCode& status) {
+    if (U_FAILURE(status)) { return; }
+    if (decnum.isNegative()) {
+        flags |= NEGATIVE_FLAG;
+    }
+    if (!decnum.isZero()) {
+        readDecNumberToBcd(decnum);
+        compact();
+    }
+}
+
+int64_t DecimalQuantity::toLong(bool truncateIfOverflow) const {
+    // NOTE: Call sites should be guarded by fitsInLong(), like this:
+    // if (dq.fitsInLong()) { /* use dq.toLong() */ } else { /* use some fallback */ }
+    // Fallback behavior upon truncateIfOverflow is to truncate at 17 digits.
+    uint64_t result = 0L;
+    int32_t upperMagnitude = std::min(scale + precision, lOptPos) - 1;
+    if (truncateIfOverflow) {
+        upperMagnitude = std::min(upperMagnitude, 17);
+    }
+    for (int32_t magnitude = upperMagnitude; magnitude >= 0; magnitude--) {
         result = result * 10 + getDigitPos(magnitude - scale);
     }
-    return result;
+    if (isNegative()) {
+        return static_cast<int64_t>(0LL - result); // i.e., -result
+    }
+    return static_cast<int64_t>(result);
 }
 
-int64_t DecimalQuantity::toFractionLong(bool includeTrailingZeros) const {
-    int64_t result = 0L;
+uint64_t DecimalQuantity::toFractionLong(bool includeTrailingZeros) const {
+    uint64_t result = 0L;
     int32_t magnitude = -1;
-    for (; (magnitude >= scale || (includeTrailingZeros && magnitude >= rReqPos)) &&
-           magnitude >= rOptPos; magnitude--) {
+    int32_t lowerMagnitude = std::max(scale, rOptPos);
+    if (includeTrailingZeros) {
+        lowerMagnitude = std::min(lowerMagnitude, rReqPos);
+    }
+    for (; magnitude >= lowerMagnitude && result <= 1e18L; magnitude--) {
         result = result * 10 + getDigitPos(magnitude - scale);
     }
+    // Remove trailing zeros; this can happen during integer overflow cases.
+    if (!includeTrailingZeros) {
+        while (result > 0 && (result % 10) == 0) {
+            result /= 10;
+        }
+    }
     return result;
 }
 
-double DecimalQuantity::toDouble() const {
-    if (isApproximate) {
-        return toDoubleFromOriginal();
+bool DecimalQuantity::fitsInLong(bool ignoreFraction) const {
+    if (isZero()) {
+        return true;
+    }
+    if (scale < 0 && !ignoreFraction) {
+        return false;
     }
+    int magnitude = getMagnitude();
+    if (magnitude < 18) {
+        return true;
+    }
+    if (magnitude > 18) {
+        return false;
+    }
+    // Hard case: the magnitude is 10^18.
+    // The largest int64 is: 9,223,372,036,854,775,807
+    for (int p = 0; p < precision; p++) {
+        int8_t digit = getDigit(18 - p);
+        static int8_t INT64_BCD[] = { 9, 2, 2, 3, 3, 7, 2, 0, 3, 6, 8, 5, 4, 7, 7, 5, 8, 0, 8 };
+        if (digit < INT64_BCD[p]) {
+            return true;
+        } else if (digit > INT64_BCD[p]) {
+            return false;
+        }
+    }
+    // Exactly equal to max long plus one.
+    return isNegative();
+}
+
+double DecimalQuantity::toDouble() const {
+    // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+    // See the comment in the header file explaining the "isApproximate" field.
+    U_ASSERT(!isApproximate);
 
     if (isNaN()) {
         return NAN;
@@ -476,42 +573,37 @@ double DecimalQuantity::toDouble() const {
         return isNegative() ? -INFINITY : INFINITY;
     }
 
-    int64_t tempLong = 0L;
-    int32_t lostDigits = precision - (precision < 17 ? precision : 17);
-    for (int shift = precision - 1; shift >= lostDigits; shift--) {
-        tempLong = tempLong * 10 + getDigitPos(shift);
+    // We are processing well-formed input, so we don't need any special options to StringToDoubleConverter.
+    StringToDoubleConverter converter(0, 0, 0, "", "");
+    UnicodeString numberString = this->toScientificString();
+    int32_t count;
+    return converter.StringToDouble(
+            reinterpret_cast<const uint16_t*>(numberString.getBuffer()),
+            numberString.length(),
+            &count);
+}
+
+void DecimalQuantity::toDecNum(DecNum& output, UErrorCode& status) const {
+    // Special handling for zero
+    if (precision == 0) {
+        output.setTo("0", status);
     }
-    double result = static_cast<double>(tempLong);
-    int32_t _scale = scale + lostDigits;
-    if (_scale >= 0) {
-        // 1e22 is the largest exact double.
-        int32_t i = _scale;
-        for (; i >= 22; i -= 22) result *= 1e22;
-        result *= DOUBLE_MULTIPLIERS[i];
-    } else {
-        // 1e22 is the largest exact double.
-        int32_t i = _scale;
-        for (; i <= -22; i += 22) result /= 1e22;
-        result /= DOUBLE_MULTIPLIERS[-i];
+
+    // Use the BCD constructor. We need to do a little bit of work to convert, though.
+    // The decNumber constructor expects most-significant first, but we store least-significant first.
+    MaybeStackArray<uint8_t, 20> ubcd(precision);
+    for (int32_t m = 0; m < precision; m++) {
+        ubcd[precision - m - 1] = static_cast<uint8_t>(getDigitPos(m));
     }
-    if (isNegative()) { result = -result; }
-    return result;
+    output.setTo(ubcd.getAlias(), precision, scale, isNegative(), status);
 }
 
-double DecimalQuantity::toDoubleFromOriginal() const {
-    double result = origDouble;
-    int32_t delta = origDelta;
-    if (delta >= 0) {
-        // 1e22 is the largest exact double.
-        for (; delta >= 22; delta -= 22) result *= 1e22;
-        result *= DOUBLE_MULTIPLIERS[delta];
-    } else {
-        // 1e22 is the largest exact double.
-        for (; delta <= -22; delta += 22) result /= 1e22;
-        result /= DOUBLE_MULTIPLIERS[-delta];
+void DecimalQuantity::truncate() {
+    if (scale < 0) {
+        shiftRight(-scale);
+        scale = 0;
+        compact();
     }
-    if (isNegative()) { result *= -1; }
-    return result;
 }
 
 void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) {
@@ -689,17 +781,63 @@ void DecimalQuantity::appendDigit(int8_t value, int32_t leadingZeros, bool appen
 }
 
 UnicodeString DecimalQuantity::toPlainString() const {
+    U_ASSERT(!isApproximate);
     UnicodeString sb;
     if (isNegative()) {
         sb.append(u'-');
     }
+    if (precision == 0 || getMagnitude() < 0) {
+        sb.append(u'0');
+    }
     for (int m = getUpperDisplayMagnitude(); m >= getLowerDisplayMagnitude(); m--) {
+        if (m == -1) { sb.append(u'.'); }
         sb.append(getDigit(m) + u'0');
-        if (m == 0) { sb.append(u'.'); }
     }
     return sb;
 }
 
+UnicodeString DecimalQuantity::toScientificString() const {
+    U_ASSERT(!isApproximate);
+    UnicodeString result;
+    if (isNegative()) {
+        result.append(u'-');
+    }
+    if (precision == 0) {
+        result.append(u"0E+0", -1);
+        return result;
+    }
+    // NOTE: It is not safe to add to lOptPos (aka maxInt) or subtract from
+    // rOptPos (aka -maxFrac) due to overflow.
+    int32_t upperPos = std::min(precision + scale, lOptPos) - scale - 1;
+    int32_t lowerPos = std::max(scale, rOptPos) - scale;
+    int32_t p = upperPos;
+    result.append(u'0' + getDigitPos(p));
+    if ((--p) >= lowerPos) {
+        result.append(u'.');
+        for (; p >= lowerPos; p--) {
+            result.append(u'0' + getDigitPos(p));
+        }
+    }
+    result.append(u'E');
+    int32_t _scale = upperPos + scale;
+    if (_scale < 0) {
+        _scale *= -1;
+        result.append(u'-');
+    } else {
+        result.append(u'+');
+    }
+    if (_scale == 0) {
+        result.append(u'0');
+    }
+    int32_t insertIndex = result.length();
+    while (_scale > 0) {
+        std::div_t res = std::div(_scale, 10);
+        result.insert(insertIndex, u'0' + res.rem);
+        _scale = res.quot;
+    }
+    return result;
+}
+
 ////////////////////////////////////////////////////
 /// End of DecimalQuantity_AbstractBCD.java      ///
 /// Start of DecimalQuantity_DualStorageBCD.java ///
@@ -707,7 +845,7 @@ UnicodeString DecimalQuantity::toPlainString() const {
 
 int8_t DecimalQuantity::getDigitPos(int32_t position) const {
     if (usingBytes) {
-        if (position < 0 || position > precision) { return 0; }
+        if (position < 0 || position >= precision) { return 0; }
         return fBCD.bcdBytes.ptr[position];
     } else {
         if (position < 0 || position >= 16) { return 0; }
@@ -819,7 +957,8 @@ void DecimalQuantity::readLongToBcd(int64_t n) {
     }
 }
 
-void DecimalQuantity::readDecNumberToBcd(decNumber *dn) {
+void DecimalQuantity::readDecNumberToBcd(const DecNum& decnum) {
+    const decNumber* dn = decnum.getRawDecNumber();
     if (dn->digits > 16) {
         ensureCapacity(dn->digits);
         for (int32_t i = 0; i < dn->digits; i++) {
@@ -919,7 +1058,7 @@ void DecimalQuantity::ensureCapacity(int32_t capacity) {
         auto bcd1 = static_cast<int8_t*>(uprv_malloc(capacity * 2 * sizeof(int8_t)));
         uprv_memcpy(bcd1, fBCD.bcdBytes.ptr, oldCapacity * sizeof(int8_t));
         // Initialize the rest of the byte array to zeros (this is done automatically in Java)
-        uprv_memset(fBCD.bcdBytes.ptr + oldCapacity, 0, (capacity - oldCapacity) * sizeof(int8_t));
+        uprv_memset(bcd1 + oldCapacity, 0, (capacity - oldCapacity) * sizeof(int8_t));
         uprv_free(fBCD.bcdBytes.ptr);
         fBCD.bcdBytes.ptr = bcd1;
         fBCD.bcdBytes.len = capacity * 2;
@@ -962,6 +1101,20 @@ void DecimalQuantity::copyBcdFrom(const DecimalQuantity &other) {
     }
 }
 
+void DecimalQuantity::moveBcdFrom(DecimalQuantity &other) {
+    setBcdToZero();
+    if (other.usingBytes) {
+        usingBytes = true;
+        fBCD.bcdBytes.ptr = other.fBCD.bcdBytes.ptr;
+        fBCD.bcdBytes.len = other.fBCD.bcdBytes.len;
+        // Take ownership away from the old instance:
+        other.fBCD.bcdBytes.ptr = nullptr;
+        other.usingBytes = false;
+    } else {
+        fBCD.bcdLong = other.fBCD.bcdLong;
+    }
+}
+
 const char16_t* DecimalQuantity::checkHealth() const {
     if (usingBytes) {
         if (precision == 0) { return u"Zero precision but we are in byte mode"; }
@@ -1000,6 +1153,11 @@ const char16_t* DecimalQuantity::checkHealth() const {
     return nullptr;
 }
 
+bool DecimalQuantity::operator==(const DecimalQuantity& other) const {
+    // FIXME: Make a faster implementation.
+    return toString() == other.toString();
+}
+
 UnicodeString DecimalQuantity::toString() const {
     MaybeStackArray<char, 30> digits(precision + 1);
     for (int32_t i = 0; i < precision; i++) {
@@ -1010,25 +1168,17 @@ UnicodeString DecimalQuantity::toString() const {
     snprintf(
             buffer8,
             sizeof(buffer8),
-            "<DecimalQuantity %d:%d:%d:%d %s %s%s%d>",
+            "<DecimalQuantity %d:%d:%d:%d %s %s%s%s%d>",
             (lOptPos > 999 ? 999 : lOptPos),
             lReqPos,
             rReqPos,
             (rOptPos < -999 ? -999 : rOptPos),
             (usingBytes ? "bytes" : "long"),
+            (isNegative() ? "-" : ""),
             (precision == 0 ? "0" : digits.getAlias()),
             "E",
             scale);
     return UnicodeString(buffer8, -1, US_INV);
 }
 
-UnicodeString DecimalQuantity::toNumberString() const {
-    MaybeStackArray<char, 30> digits(precision + 11);
-    for (int32_t i = 0; i < precision; i++) {
-        digits[i] = getDigitPos(precision - i - 1) + '0';
-    }
-    snprintf(digits.getAlias() + precision, 11, "E%d", scale);
-    return UnicodeString(digits.getAlias(), -1, US_INV);
-}
-
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_decimalquantity.h b/deps/icu-small/source/i18n/number_decimalquantity.h
index 4309c3c6380ac4..8e04dea7eb5c43 100644
--- a/deps/icu-small/source/i18n/number_decimalquantity.h
+++ b/deps/icu-small/source/i18n/number_decimalquantity.h
@@ -3,13 +3,12 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_DECIMALQUANTITY_H__
 #define __NUMBER_DECIMALQUANTITY_H__
 
 #include <cstdint>
 #include "unicode/umachine.h"
-#include "decNumber.h"
 #include "standardplural.h"
 #include "plurrule_impl.h"
 #include "number_types.h"
@@ -17,6 +16,9 @@
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
 
+// Forward-declare (maybe don't want number_utils.h included here):
+class DecNum;
+
 /**
  * An class for representing a number to be processed by the decimal formatting pipeline. Includes
  * methods for rounding, plural rules, and decimal digit extraction.
@@ -33,9 +35,12 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     /** Copy constructor. */
     DecimalQuantity(const DecimalQuantity &other);
 
+    /** Move constructor. */
+    DecimalQuantity(DecimalQuantity &&src) U_NOEXCEPT;
+
     DecimalQuantity();
 
-    ~DecimalQuantity();
+    ~DecimalQuantity() override;
 
     /**
      * Sets this instance to be equal to another instance.
@@ -44,6 +49,9 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
      */
     DecimalQuantity &operator=(const DecimalQuantity &other);
 
+    /** Move assignment */
+    DecimalQuantity &operator=(DecimalQuantity&& src) U_NOEXCEPT;
+
     /**
      * Sets the minimum and maximum integer digits that this {@link DecimalQuantity} should generate.
      * This method does not perform rounding.
@@ -71,7 +79,10 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
      * @param mathContext The {@link RoundingMode} to use if rounding is necessary.
      */
     void roundToIncrement(double roundingIncrement, RoundingMode roundingMode,
-                          int32_t minMaxFrac, UErrorCode& status);
+                          int32_t maxFrac, UErrorCode& status);
+
+    /** Removes all fraction digits. */
+    void truncate();
 
     /**
      * Rounds the number to a specified magnitude (power of ten).
@@ -89,19 +100,30 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     void roundToInfinity();
 
     /**
-     * Multiply the internal value.
+     * Multiply the internal value. Uses decNumber.
+     *
+     * @param multiplicand The value by which to multiply.
+     */
+    void multiplyBy(const DecNum& multiplicand, UErrorCode& status);
+
+    /**
+     * Divide the internal value. Uses decNumber.
      *
      * @param multiplicand The value by which to multiply.
      */
-    void multiplyBy(int32_t multiplicand);
+    void divideBy(const DecNum& divisor, UErrorCode& status);
+
+    /** Flips the sign from positive to negative and back. */
+    void negate();
 
     /**
      * Scales the number by a power of ten. For example, if the value is currently "1234.56", calling
      * this method with delta=-3 will change the value to "1.23456".
      *
      * @param delta The number of magnitudes of ten to change by.
+     * @return true if integer overflow occured; false otherwise.
      */
-    void adjustMagnitude(int32_t delta);
+    bool adjustMagnitude(int32_t delta);
 
     /**
      * @return The power of ten corresponding to the most significant nonzero digit.
@@ -124,13 +146,23 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     /** @return Whether the value represented by this {@link DecimalQuantity} is not a number. */
     bool isNaN() const U_OVERRIDE;
 
-    int64_t toLong() const;
+    /** @param truncateIfOverflow if false and the number does NOT fit, fails with an assertion error. */
+    int64_t toLong(bool truncateIfOverflow = false) const;
 
-    int64_t toFractionLong(bool includeTrailingZeros) const;
+    uint64_t toFractionLong(bool includeTrailingZeros) const;
+
+    /**
+     * Returns whether or not a Long can fully represent the value stored in this DecimalQuantity.
+     * @param ignoreFraction if true, silently ignore digits after the decimal place.
+     */
+    bool fitsInLong(bool ignoreFraction = false) const;
 
     /** @return The value contained in this {@link DecimalQuantity} approximated as a double. */
     double toDouble() const;
 
+    /** Computes a DecNum representation of this DecimalQuantity, saving it to the output parameter. */
+    void toDecNum(DecNum& output, UErrorCode& status) const;
+
     DecimalQuantity &setToInt(int32_t n);
 
     DecimalQuantity &setToLong(int64_t n);
@@ -138,8 +170,10 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     DecimalQuantity &setToDouble(double n);
 
     /** decNumber is similar to BigDecimal in Java. */
+    DecimalQuantity &setToDecNumber(StringPiece n, UErrorCode& status);
 
-    DecimalQuantity &setToDecNumber(StringPiece n);
+    /** Internal method if the caller already has a DecNum. */
+    DecimalQuantity &setToDecNum(const DecNum& n, UErrorCode& status);
 
     /**
      * Appends a digit, optionally with one or more leading zeros, to the end of the value represented
@@ -160,17 +194,10 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
      */
     void appendDigit(int8_t value, int32_t leadingZeros, bool appendAsInteger);
 
-    /**
-     * Computes the plural form for this number based on the specified set of rules.
-     *
-     * @param rules A {@link PluralRules} object representing the set of rules.
-     * @return The {@link StandardPlural} according to the PluralRules. If the plural form is not in
-     *     the set of standard plurals, {@link StandardPlural#OTHER} is returned instead.
-     */
-    StandardPlural::Form getStandardPlural(const PluralRules *rules) const;
-
     double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
 
+    bool hasIntegerValue() const U_OVERRIDE;
+
     /**
      * Gets the digit at the specified magnitude. For example, if the represented number is 12.3,
      * getDigit(-1) returns 3, since 3 is the digit corresponding to 10^-1.
@@ -223,10 +250,10 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
 
     UnicodeString toString() const;
 
-    /* Returns the string in exponential notation. */
-    UnicodeString toNumberString() const;
+    /** Returns the string in standard exponential notation. */
+    UnicodeString toScientificString() const;
 
-    /* Returns the string without exponential notation. Slightly slower than toNumberString(). */
+    /** Returns the string without exponential notation. Slightly slower than toScientificString(). */
     UnicodeString toPlainString() const;
 
     /** Visible for testing */
@@ -235,6 +262,17 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
     /** Visible for testing */
     inline bool isExplicitExactDouble() { return explicitExactDouble; };
 
+    bool operator==(const DecimalQuantity& other) const;
+
+    inline bool operator!=(const DecimalQuantity& other) const {
+        return !(*this == other);
+    }
+
+    /**
+     * Bogus flag for when a DecimalQuantity is stored on the stack.
+     */
+    bool bogus = false;
+
   private:
     /**
      * The power of ten corresponding to the least significant digit in the BCD. For example, if this
@@ -396,12 +434,16 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
      */
     void readLongToBcd(int64_t n);
 
-    void readDecNumberToBcd(decNumber *dn);
+    void readDecNumberToBcd(const DecNum& dn);
 
     void readDoubleConversionToBcd(const char* buffer, int32_t length, int32_t point);
 
+    void copyFieldsFrom(const DecimalQuantity& other);
+
     void copyBcdFrom(const DecimalQuantity &other);
 
+    void moveBcdFrom(DecimalQuantity& src);
+
     /**
      * Removes trailing zeros from the BCD (adjusting the scale as required) and then computes the
      * precision. The precision is the number of digits in the number up through the greatest nonzero
@@ -418,12 +460,10 @@ class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
 
     void _setToDoubleFast(double n);
 
-    void _setToDecNumber(decNumber *n);
+    void _setToDecNum(const DecNum& dn, UErrorCode& status);
 
     void convertToAccurateDouble();
 
-    double toDoubleFromOriginal() const;
-
     /** Ensure that a byte array of at least 40 digits is allocated. */
     void ensureCapacity();
 
diff --git a/deps/icu-small/source/i18n/number_decimfmtprops.cpp b/deps/icu-small/source/i18n/number_decimfmtprops.cpp
index cc57cfce6ac1fa..6754fe19eca56c 100644
--- a/deps/icu-small/source/i18n/number_decimfmtprops.cpp
+++ b/deps/icu-small/source/i18n/number_decimfmtprops.cpp
@@ -3,14 +3,29 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "number_decimfmtprops.h"
+#include "umutex.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
+
+namespace {
+
+char kRawDefaultProperties[sizeof(DecimalFormatProperties)];
+
+icu::UInitOnce gDefaultPropertiesInitOnce = U_INITONCE_INITIALIZER;
+
+void U_CALLCONV initDefaultProperties(UErrorCode&) {
+    new(kRawDefaultProperties) DecimalFormatProperties(); // set to the default instance
+}
+
+}
+
+
 DecimalFormatProperties::DecimalFormatProperties() {
     clear();
 }
@@ -23,8 +38,10 @@ void DecimalFormatProperties::clear() {
     decimalPatternMatchRequired = false;
     decimalSeparatorAlwaysShown = false;
     exponentSignAlwaysShown = false;
+    formatFailIfMoreThanMaxDigits = false;
     formatWidth = -1;
     groupingSize = -1;
+    groupingUsed = true;
     magnitudeMultiplier = 0;
     maximumFractionDigits = -1;
     maximumIntegerDigits = -1;
@@ -34,7 +51,8 @@ void DecimalFormatProperties::clear() {
     minimumGroupingDigits = -1;
     minimumIntegerDigits = -1;
     minimumSignificantDigits = -1;
-    multiplier = 0;
+    multiplier = 1;
+    multiplierScale = 0;
     negativePrefix.setToBogus();
     negativePrefixPattern.setToBogus();
     negativeSuffix.setToBogus();
@@ -43,9 +61,10 @@ void DecimalFormatProperties::clear() {
     padString.setToBogus();
     parseCaseSensitive = false;
     parseIntegerOnly = false;
-    parseLenient = false;
+    parseMode.nullify();
     parseNoExponent = false;
     parseToBigDecimal = false;
+    parseAllInput = UNUM_MAYBE;
     positivePrefix.setToBogus();
     positivePrefixPattern.setToBogus();
     positiveSuffix.setToBogus();
@@ -56,47 +75,70 @@ void DecimalFormatProperties::clear() {
     signAlwaysShown = false;
 }
 
-bool DecimalFormatProperties::operator==(const DecimalFormatProperties &other) const {
+bool
+DecimalFormatProperties::_equals(const DecimalFormatProperties& other, bool ignoreForFastFormat) const {
     bool eq = true;
+
+    // Properties that must be equal both normally and for fast-path formatting
     eq = eq && compactStyle == other.compactStyle;
     eq = eq && currency == other.currency;
     eq = eq && currencyPluralInfo.fPtr.getAlias() == other.currencyPluralInfo.fPtr.getAlias();
     eq = eq && currencyUsage == other.currencyUsage;
-    eq = eq && decimalPatternMatchRequired == other.decimalPatternMatchRequired;
     eq = eq && decimalSeparatorAlwaysShown == other.decimalSeparatorAlwaysShown;
     eq = eq && exponentSignAlwaysShown == other.exponentSignAlwaysShown;
+    eq = eq && formatFailIfMoreThanMaxDigits == other.formatFailIfMoreThanMaxDigits;
     eq = eq && formatWidth == other.formatWidth;
-    eq = eq && groupingSize == other.groupingSize;
     eq = eq && magnitudeMultiplier == other.magnitudeMultiplier;
-    eq = eq && maximumFractionDigits == other.maximumFractionDigits;
-    eq = eq && maximumIntegerDigits == other.maximumIntegerDigits;
     eq = eq && maximumSignificantDigits == other.maximumSignificantDigits;
     eq = eq && minimumExponentDigits == other.minimumExponentDigits;
-    eq = eq && minimumFractionDigits == other.minimumFractionDigits;
     eq = eq && minimumGroupingDigits == other.minimumGroupingDigits;
-    eq = eq && minimumIntegerDigits == other.minimumIntegerDigits;
     eq = eq && minimumSignificantDigits == other.minimumSignificantDigits;
     eq = eq && multiplier == other.multiplier;
+    eq = eq && multiplierScale == other.multiplierScale;
     eq = eq && negativePrefix == other.negativePrefix;
-    eq = eq && negativePrefixPattern == other.negativePrefixPattern;
     eq = eq && negativeSuffix == other.negativeSuffix;
-    eq = eq && negativeSuffixPattern == other.negativeSuffixPattern;
     eq = eq && padPosition == other.padPosition;
     eq = eq && padString == other.padString;
-    eq = eq && parseCaseSensitive == other.parseCaseSensitive;
-    eq = eq && parseIntegerOnly == other.parseIntegerOnly;
-    eq = eq && parseLenient == other.parseLenient;
-    eq = eq && parseNoExponent == other.parseNoExponent;
-    eq = eq && parseToBigDecimal == other.parseToBigDecimal;
     eq = eq && positivePrefix == other.positivePrefix;
-    eq = eq && positivePrefixPattern == other.positivePrefixPattern;
     eq = eq && positiveSuffix == other.positiveSuffix;
-    eq = eq && positiveSuffixPattern == other.positiveSuffixPattern;
     eq = eq && roundingIncrement == other.roundingIncrement;
     eq = eq && roundingMode == other.roundingMode;
     eq = eq && secondaryGroupingSize == other.secondaryGroupingSize;
     eq = eq && signAlwaysShown == other.signAlwaysShown;
+
+    if (ignoreForFastFormat) {
+        return eq;
+    }
+
+    // Properties ignored by fast-path formatting
+    // Formatting (special handling required):
+    eq = eq && groupingSize == other.groupingSize;
+    eq = eq && groupingUsed == other.groupingUsed;
+    eq = eq && minimumFractionDigits == other.minimumFractionDigits;
+    eq = eq && maximumFractionDigits == other.maximumFractionDigits;
+    eq = eq && maximumIntegerDigits == other.maximumIntegerDigits;
+    eq = eq && minimumIntegerDigits == other.minimumIntegerDigits;
+    eq = eq && negativePrefixPattern == other.negativePrefixPattern;
+    eq = eq && negativeSuffixPattern == other.negativeSuffixPattern;
+    eq = eq && positivePrefixPattern == other.positivePrefixPattern;
+    eq = eq && positiveSuffixPattern == other.positiveSuffixPattern;
+
+    // Parsing (always safe to ignore):
+    eq = eq && decimalPatternMatchRequired == other.decimalPatternMatchRequired;
+    eq = eq && parseCaseSensitive == other.parseCaseSensitive;
+    eq = eq && parseIntegerOnly == other.parseIntegerOnly;
+    eq = eq && parseMode == other.parseMode;
+    eq = eq && parseNoExponent == other.parseNoExponent;
+    eq = eq && parseToBigDecimal == other.parseToBigDecimal;
+    eq = eq && parseAllInput == other.parseAllInput;
+
     return eq;
 }
 
+bool DecimalFormatProperties::equalsDefaultExceptFastFormat() const {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    umtx_initOnce(gDefaultPropertiesInitOnce, &initDefaultProperties, localStatus);
+    return _equals(*reinterpret_cast<DecimalFormatProperties*>(kRawDefaultProperties), true);
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_decimfmtprops.h b/deps/icu-small/source/i18n/number_decimfmtprops.h
index 96356cad45321d..f288b6e0d97f58 100644
--- a/deps/icu-small/source/i18n/number_decimfmtprops.h
+++ b/deps/icu-small/source/i18n/number_decimfmtprops.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_DECIMFMTPROPS_H__
 #define __NUMBER_DECIMFMTPROPS_H__
 
@@ -30,21 +30,65 @@ template class U_I18N_API LocalPointer<CurrencyPluralInfo>;
 namespace number {
 namespace impl {
 
-// TODO: Figure out a nicer way to deal with CurrencyPluralInfo.
 // Exported as U_I18N_API because it is a public member field of exported DecimalFormatProperties
-struct U_I18N_API CurrencyPluralInfoWrapper {
+// Using this wrapper is rather unfortunate, but is needed on Windows platforms in order to allow
+// for DLL-exporting an fully specified template instantiation.
+class U_I18N_API CurrencyPluralInfoWrapper {
+public:
     LocalPointer<CurrencyPluralInfo> fPtr;
 
-    CurrencyPluralInfoWrapper() {}
+    CurrencyPluralInfoWrapper() = default;
+
     CurrencyPluralInfoWrapper(const CurrencyPluralInfoWrapper& other) {
         if (!other.fPtr.isNull()) {
             fPtr.adoptInstead(new CurrencyPluralInfo(*other.fPtr));
         }
     }
+
+    CurrencyPluralInfoWrapper& operator=(const CurrencyPluralInfoWrapper& other) {
+        if (!other.fPtr.isNull()) {
+            fPtr.adoptInstead(new CurrencyPluralInfo(*other.fPtr));
+        }
+        return *this;
+    }
+};
+
+/** Controls the set of rules for parsing a string from the old DecimalFormat API. */
+enum ParseMode {
+    /**
+     * Lenient mode should be used if you want to accept malformed user input. It will use heuristics
+     * to attempt to parse through typographical errors in the string.
+     */
+            PARSE_MODE_LENIENT,
+
+    /**
+     * Strict mode should be used if you want to require that the input is well-formed. More
+     * specifically, it differs from lenient mode in the following ways:
+     *
+     * <ul>
+     * <li>Grouping widths must match the grouping settings. For example, "12,3,45" will fail if the
+     * grouping width is 3, as in the pattern "#,##0".
+     * <li>The string must contain a complete prefix and suffix. For example, if the pattern is
+     * "{#};(#)", then "{123}" or "(123)" would match, but "{123", "123}", and "123" would all fail.
+     * (The latter strings would be accepted in lenient mode.)
+     * <li>Whitespace may not appear at arbitrary places in the string. In lenient mode, whitespace
+     * is allowed to occur arbitrarily before and after prefixes and exponent separators.
+     * <li>Leading grouping separators are not allowed, as in ",123".
+     * <li>Minus and plus signs can only appear if specified in the pattern. In lenient mode, a plus
+     * or minus sign can always precede a number.
+     * <li>The set of characters that can be interpreted as a decimal or grouping separator is
+     * smaller.
+     * <li><strong>If currency parsing is enabled,</strong> currencies must only appear where
+     * specified in either the current pattern string or in a valid pattern string for the current
+     * locale. For example, if the pattern is "¤0.00", then "$1.23" would match, but "1.23$" would
+     * fail to match.
+     * </ul>
+     */
+            PARSE_MODE_STRICT,
 };
 
 // Exported as U_I18N_API because it is needed for the unit test PatternStringTest
-struct U_I18N_API DecimalFormatProperties {
+struct U_I18N_API DecimalFormatProperties : public UMemory {
 
   public:
     NullableValue<UNumberCompactStyle> compactStyle;
@@ -54,9 +98,11 @@ struct U_I18N_API DecimalFormatProperties {
     bool decimalPatternMatchRequired;
     bool decimalSeparatorAlwaysShown;
     bool exponentSignAlwaysShown;
+    bool formatFailIfMoreThanMaxDigits; // ICU4C-only
     int32_t formatWidth;
     int32_t groupingSize;
-    int32_t magnitudeMultiplier;
+    bool groupingUsed;
+    int32_t magnitudeMultiplier; // internal field like multiplierScale but separate to avoid conflict
     int32_t maximumFractionDigits;
     int32_t maximumIntegerDigits;
     int32_t maximumSignificantDigits;
@@ -66,6 +112,7 @@ struct U_I18N_API DecimalFormatProperties {
     int32_t minimumIntegerDigits;
     int32_t minimumSignificantDigits;
     int32_t multiplier;
+    int32_t multiplierScale; // ICU4C-only
     UnicodeString negativePrefix;
     UnicodeString negativePrefixPattern;
     UnicodeString negativeSuffix;
@@ -74,9 +121,10 @@ struct U_I18N_API DecimalFormatProperties {
     UnicodeString padString;
     bool parseCaseSensitive;
     bool parseIntegerOnly;
-    bool parseLenient;
+    NullableValue<ParseMode> parseMode;
     bool parseNoExponent;
-    bool parseToBigDecimal;
+    bool parseToBigDecimal; // TODO: Not needed in ICU4C?
+    UNumberFormatAttributeValue parseAllInput; // ICU4C-only
     //PluralRules pluralRules;
     UnicodeString positivePrefix;
     UnicodeString positivePrefixPattern;
@@ -89,13 +137,20 @@ struct U_I18N_API DecimalFormatProperties {
 
     DecimalFormatProperties();
 
-    //DecimalFormatProperties(const DecimalFormatProperties &other) = default;
+    inline bool operator==(const DecimalFormatProperties& other) const {
+        return _equals(other, false);
+    }
 
-    DecimalFormatProperties &operator=(const DecimalFormatProperties &other) = default;
+    void clear();
 
-    bool operator==(const DecimalFormatProperties &other) const;
+    /**
+     * Checks for equality to the default DecimalFormatProperties, but ignores the prescribed set of
+     * options for fast-path formatting.
+     */
+    bool equalsDefaultExceptFastFormat() const;
 
-    void clear();
+  private:
+    bool _equals(const DecimalFormatProperties& other, bool ignoreForFastFormat) const;
 };
 
 } // namespace impl
diff --git a/deps/icu-small/source/i18n/number_decnum.h b/deps/icu-small/source/i18n/number_decnum.h
new file mode 100644
index 00000000000000..a7793470b55695
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_decnum.h
@@ -0,0 +1,77 @@
+// © 2017 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMBER_DECNUM_H__
+#define __NUMBER_DECNUM_H__
+
+#include "decNumber.h"
+#include "charstr.h"
+
+U_NAMESPACE_BEGIN
+
+#define DECNUM_INITIAL_CAPACITY 34
+
+// Export an explicit template instantiation of the MaybeStackHeaderAndArray that is used as a data member of DecNum.
+// When building DLLs for Windows this is required even though no direct access to the MaybeStackHeaderAndArray leaks out of the i18n library.
+// (See digitlst.h, pluralaffix.h, datefmt.h, and others for similar examples.)
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackHeaderAndArray<decNumber, char, DECNUM_INITIAL_CAPACITY>;
+#endif
+
+namespace number {
+namespace impl {
+
+/** A very thin C++ wrapper around decNumber.h */
+// Exported as U_I18N_API for tests
+class U_I18N_API DecNum : public UMemory {
+  public:
+    DecNum();  // leaves object in valid but undefined state
+
+    // Copy-like constructor; use the default move operators.
+    DecNum(const DecNum& other, UErrorCode& status);
+
+    /** Sets the decNumber to the StringPiece. */
+    void setTo(StringPiece str, UErrorCode& status);
+
+    /** Sets the decNumber to the NUL-terminated char string. */
+    void setTo(const char* str, UErrorCode& status);
+
+    /** Uses double_conversion to set this decNumber to the given double. */
+    void setTo(double d, UErrorCode& status);
+
+    /** Sets the decNumber to the BCD representation. */
+    void setTo(const uint8_t* bcd, int32_t length, int32_t scale, bool isNegative, UErrorCode& status);
+
+    void normalize();
+
+    void multiplyBy(const DecNum& rhs, UErrorCode& status);
+
+    void divideBy(const DecNum& rhs, UErrorCode& status);
+
+    bool isNegative() const;
+
+    bool isZero() const;
+
+    inline const decNumber* getRawDecNumber() const {
+        return fData.getAlias();
+    }
+
+  private:
+    static constexpr int32_t kDefaultDigits = DECNUM_INITIAL_CAPACITY;
+    MaybeStackHeaderAndArray<decNumber, char, kDefaultDigits> fData;
+    decContext fContext;
+
+    void _setTo(const char* str, int32_t maxDigits, UErrorCode& status);
+};
+
+} // namespace impl
+} // namespace number
+
+U_NAMESPACE_END
+
+#endif // __NUMBER_DECNUM_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_fluent.cpp b/deps/icu-small/source/i18n/number_fluent.cpp
index 27113106c50451..687adb6b5babd2 100644
--- a/deps/icu-small/source/i18n/number_fluent.cpp
+++ b/deps/icu-small/source/i18n/number_fluent.cpp
@@ -3,20 +3,26 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "uassert.h"
 #include "unicode/numberformatter.h"
 #include "number_decimalquantity.h"
 #include "number_formatimpl.h"
 #include "umutex.h"
+#include "number_asformat.h"
+#include "number_skeletons.h"
+#include "number_utils.h"
+#include "number_utypes.h"
+#include "util.h"
+#include "fphdlimp.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::notation(const Notation &notation) const {
+Derived NumberFormatterSettings<Derived>::notation(const Notation& notation) const& {
     Derived copy(*this);
     // NOTE: Slicing is OK.
     copy.fMacros.notation = notation;
@@ -24,7 +30,15 @@ Derived NumberFormatterSettings<Derived>::notation(const Notation &notation) con
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit &unit) const {
+Derived NumberFormatterSettings<Derived>::notation(const Notation& notation)&& {
+    Derived move(std::move(*this));
+    // NOTE: Slicing is OK.
+    move.fMacros.notation = notation;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit) const& {
     Derived copy(*this);
     // NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
     // TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
@@ -33,21 +47,41 @@ Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit &unit) con
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit *unit) const {
+Derived NumberFormatterSettings<Derived>::unit(const icu::MeasureUnit& unit)&& {
+    Derived move(std::move(*this));
+    // See comments above about slicing.
+    move.fMacros.unit = unit;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit) const& {
     Derived copy(*this);
-    // Just copy the unit into the MacroProps by value, and delete it since we have ownership.
+    // Just move the unit into the MacroProps by value, and delete it since we have ownership.
     // NOTE: Slicing occurs here. However, CurrencyUnit can be restored from MeasureUnit.
     // TimeUnit may be affected, but TimeUnit is not as relevant to number formatting.
     if (unit != nullptr) {
-      // TODO: On nullptr, reset to default value?
-        copy.fMacros.unit = *unit;
+        // TODO: On nullptr, reset to default value?
+        copy.fMacros.unit = std::move(*unit);
         delete unit;
     }
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit &perUnit) const {
+Derived NumberFormatterSettings<Derived>::adoptUnit(icu::MeasureUnit* unit)&& {
+    Derived move(std::move(*this));
+    // See comments above about slicing and ownership.
+    if (unit != nullptr) {
+        // TODO: On nullptr, reset to default value?
+        move.fMacros.unit = std::move(*unit);
+        delete unit;
+    }
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit) const& {
     Derived copy(*this);
     // See comments above about slicing.
     copy.fMacros.perUnit = perUnit;
@@ -55,27 +89,69 @@ Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit &perUni
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit *perUnit) const {
+Derived NumberFormatterSettings<Derived>::perUnit(const icu::MeasureUnit& perUnit)&& {
+    Derived move(std::move(*this));
+    // See comments above about slicing.
+    move.fMacros.perUnit = perUnit;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit) const& {
     Derived copy(*this);
     // See comments above about slicing and ownership.
     if (perUnit != nullptr) {
-      // TODO: On nullptr, reset to default value?
-        copy.fMacros.perUnit = *perUnit;
+        // TODO: On nullptr, reset to default value?
+        copy.fMacros.perUnit = std::move(*perUnit);
         delete perUnit;
     }
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::rounding(const Rounder &rounder) const {
+Derived NumberFormatterSettings<Derived>::adoptPerUnit(icu::MeasureUnit* perUnit)&& {
+    Derived move(std::move(*this));
+    // See comments above about slicing and ownership.
+    if (perUnit != nullptr) {
+        // TODO: On nullptr, reset to default value?
+        move.fMacros.perUnit = std::move(*perUnit);
+        delete perUnit;
+    }
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::precision(const Precision& precision) const& {
     Derived copy(*this);
     // NOTE: Slicing is OK.
-    copy.fMacros.rounder = rounder;
+    copy.fMacros.precision = precision;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::grouping(const UGroupingStrategy &strategy) const {
+Derived NumberFormatterSettings<Derived>::precision(const Precision& precision)&& {
+    Derived move(std::move(*this));
+    // NOTE: Slicing is OK.
+    move.fMacros.precision = precision;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode) const& {
+    Derived copy(*this);
+    copy.fMacros.roundingMode = roundingMode;
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::roundingMode(UNumberFormatRoundingMode roundingMode)&& {
+    Derived move(std::move(*this));
+    move.fMacros.roundingMode = roundingMode;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy) const& {
     Derived copy(*this);
     // NOTE: This is slightly different than how the setting is stored in Java
     // because we want to put it on the stack.
@@ -84,61 +160,174 @@ Derived NumberFormatterSettings<Derived>::grouping(const UGroupingStrategy &stra
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth &style) const {
+Derived NumberFormatterSettings<Derived>::grouping(UGroupingStrategy strategy)&& {
+    Derived move(std::move(*this));
+    move.fMacros.grouper = Grouper::forStrategy(strategy);
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style) const& {
     Derived copy(*this);
     copy.fMacros.integerWidth = style;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols &symbols) const {
+Derived NumberFormatterSettings<Derived>::integerWidth(const IntegerWidth& style)&& {
+    Derived move(std::move(*this));
+    move.fMacros.integerWidth = style;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols) const& {
     Derived copy(*this);
     copy.fMacros.symbols.setTo(symbols);
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem *ns) const {
+Derived NumberFormatterSettings<Derived>::symbols(const DecimalFormatSymbols& symbols)&& {
+    Derived move(std::move(*this));
+    move.fMacros.symbols.setTo(symbols);
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns) const& {
     Derived copy(*this);
     copy.fMacros.symbols.setTo(ns);
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::unitWidth(const UNumberUnitWidth &width) const {
+Derived NumberFormatterSettings<Derived>::adoptSymbols(NumberingSystem* ns)&& {
+    Derived move(std::move(*this));
+    move.fMacros.symbols.setTo(ns);
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width) const& {
     Derived copy(*this);
     copy.fMacros.unitWidth = width;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::sign(const UNumberSignDisplay &style) const {
+Derived NumberFormatterSettings<Derived>::unitWidth(UNumberUnitWidth width)&& {
+    Derived move(std::move(*this));
+    move.fMacros.unitWidth = width;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style) const& {
     Derived copy(*this);
     copy.fMacros.sign = style;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::decimal(const UNumberDecimalSeparatorDisplay &style) const {
+Derived NumberFormatterSettings<Derived>::sign(UNumberSignDisplay style)&& {
+    Derived move(std::move(*this));
+    move.fMacros.sign = style;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style) const& {
     Derived copy(*this);
     copy.fMacros.decimal = style;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::padding(const Padder &padder) const {
+Derived NumberFormatterSettings<Derived>::decimal(UNumberDecimalSeparatorDisplay style)&& {
+    Derived move(std::move(*this));
+    move.fMacros.decimal = style;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::scale(const Scale& scale) const& {
+    Derived copy(*this);
+    copy.fMacros.scale = scale;
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::scale(const Scale& scale)&& {
+    Derived move(std::move(*this));
+    move.fMacros.scale = scale;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::padding(const Padder& padder) const& {
     Derived copy(*this);
     copy.fMacros.padder = padder;
     return copy;
 }
 
 template<typename Derived>
-Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold) const {
+Derived NumberFormatterSettings<Derived>::padding(const Padder& padder)&& {
+    Derived move(std::move(*this));
+    move.fMacros.padder = padder;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold) const& {
     Derived copy(*this);
     copy.fMacros.threshold = threshold;
     return copy;
 }
 
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::threshold(int32_t threshold)&& {
+    Derived move(std::move(*this));
+    move.fMacros.threshold = threshold;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros) const& {
+    Derived copy(*this);
+    copy.fMacros = macros;
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(const impl::MacroProps& macros)&& {
+    Derived move(std::move(*this));
+    move.fMacros = macros;
+    return move;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros) const& {
+    Derived copy(*this);
+    copy.fMacros = std::move(macros);
+    return copy;
+}
+
+template<typename Derived>
+Derived NumberFormatterSettings<Derived>::macros(impl::MacroProps&& macros)&& {
+    Derived move(std::move(*this));
+    move.fMacros = std::move(macros);
+    return move;
+}
+
+template<typename Derived>
+UnicodeString NumberFormatterSettings<Derived>::toSkeleton(UErrorCode& status) const {
+    if (fMacros.copyErrorTo(status)) {
+        return ICU_Utility::makeBogusString();
+    }
+    return skeleton::generate(fMacros, status);
+}
+
 // Declare all classes that implement NumberFormatterSettings
 // See https://stackoverflow.com/a/495056/1407170
 template
@@ -152,38 +341,135 @@ UnlocalizedNumberFormatter NumberFormatter::with() {
     return result;
 }
 
-LocalizedNumberFormatter NumberFormatter::withLocale(const Locale &locale) {
+LocalizedNumberFormatter NumberFormatter::withLocale(const Locale& locale) {
     return with().locale(locale);
 }
 
-// Make the child class constructor that takes the parent class call the parent class's copy constructor
-UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(
-        const NumberFormatterSettings <UnlocalizedNumberFormatter> &other)
-        : NumberFormatterSettings<UnlocalizedNumberFormatter>(other) {
+UnlocalizedNumberFormatter
+NumberFormatter::forSkeleton(const UnicodeString& skeleton, UErrorCode& status) {
+    return skeleton::create(skeleton, status);
+}
+
+
+template<typename T> using NFS = NumberFormatterSettings<T>;
+using LNF = LocalizedNumberFormatter;
+using UNF = UnlocalizedNumberFormatter;
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const UNF& other)
+        : UNF(static_cast<const NFS<UNF>&>(other)) {}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(const NFS<UNF>& other)
+        : NFS<UNF>(other) {
+    // No additional fields to assign
+}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(UNF&& src) U_NOEXCEPT
+        : UNF(static_cast<NFS<UNF>&&>(src)) {}
+
+UnlocalizedNumberFormatter::UnlocalizedNumberFormatter(NFS<UNF>&& src) U_NOEXCEPT
+        : NFS<UNF>(std::move(src)) {
+    // No additional fields to assign
+}
+
+UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(const UNF& other) {
+    NFS<UNF>::operator=(static_cast<const NFS<UNF>&>(other));
+    // No additional fields to assign
+    return *this;
+}
+
+UnlocalizedNumberFormatter& UnlocalizedNumberFormatter::operator=(UNF&& src) U_NOEXCEPT {
+    NFS<UNF>::operator=(static_cast<NFS<UNF>&&>(src));
+    // No additional fields to assign
+    return *this;
+}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(const LNF& other)
+        : LNF(static_cast<const NFS<LNF>&>(other)) {}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(const NFS<LNF>& other)
+        : NFS<LNF>(other) {
+    // No additional fields to assign (let call count and compiled formatter reset to defaults)
+}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(LocalizedNumberFormatter&& src) U_NOEXCEPT
+        : LNF(static_cast<NFS<LNF>&&>(src)) {}
+
+LocalizedNumberFormatter::LocalizedNumberFormatter(NFS<LNF>&& src) U_NOEXCEPT
+        : NFS<LNF>(std::move(src)) {
+    // For the move operators, copy over the compiled formatter.
+    // Note: if the formatter is not compiled, call count information is lost.
+    if (static_cast<LNF&&>(src).fCompiled != nullptr) {
+        lnfMoveHelper(static_cast<LNF&&>(src));
+    }
+}
+
+LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(const LNF& other) {
+    NFS<LNF>::operator=(static_cast<const NFS<LNF>&>(other));
+    // No additional fields to assign (let call count and compiled formatter reset to defaults)
+    return *this;
+}
+
+LocalizedNumberFormatter& LocalizedNumberFormatter::operator=(LNF&& src) U_NOEXCEPT {
+    NFS<LNF>::operator=(static_cast<NFS<LNF>&&>(src));
+    // For the move operators, copy over the compiled formatter.
+    // Note: if the formatter is not compiled, call count information is lost.
+    if (static_cast<LNF&&>(src).fCompiled != nullptr) {
+        // Formatter is compiled
+        lnfMoveHelper(static_cast<LNF&&>(src));
+    } else {
+        // Reset to default values.
+        auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
+        umtx_storeRelease(*callCount, 0);
+        fCompiled = nullptr;
+    }
+    return *this;
+}
+
+void LocalizedNumberFormatter::lnfMoveHelper(LNF&& src) {
+    // Copy over the compiled formatter and set call count to INT32_MIN as in computeCompiled().
+    // Don't copy the call count directly because doing so requires a loadAcquire/storeRelease.
+    // The bits themselves appear to be platform-dependent, so copying them might not be safe.
+    auto* callCount = reinterpret_cast<u_atomic_int32_t*>(fUnsafeCallCount);
+    umtx_storeRelease(*callCount, INT32_MIN);
+    fCompiled = src.fCompiled;
+    // Reset the source object to leave it in a safe state.
+    auto* srcCallCount = reinterpret_cast<u_atomic_int32_t*>(src.fUnsafeCallCount);
+    umtx_storeRelease(*srcCallCount, 0);
+    src.fCompiled = nullptr;
 }
 
-// Make the child class constructor that takes the parent class call the parent class's copy constructor
-// For LocalizedNumberFormatter, also copy over the extra fields
-LocalizedNumberFormatter::LocalizedNumberFormatter(
-        const NumberFormatterSettings <LocalizedNumberFormatter> &other)
-        : NumberFormatterSettings<LocalizedNumberFormatter>(other) {
-    // No additional copies required
+
+LocalizedNumberFormatter::~LocalizedNumberFormatter() {
+    delete fCompiled;
 }
 
-LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps &macros, const Locale &locale) {
+LocalizedNumberFormatter::LocalizedNumberFormatter(const MacroProps& macros, const Locale& locale) {
     fMacros = macros;
     fMacros.locale = locale;
 }
 
-LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale &locale) const {
+LocalizedNumberFormatter::LocalizedNumberFormatter(MacroProps&& macros, const Locale& locale) {
+    fMacros = std::move(macros);
+    fMacros.locale = locale;
+}
+
+LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale) const& {
     return LocalizedNumberFormatter(fMacros, locale);
 }
 
-SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper &other) {
+LocalizedNumberFormatter UnlocalizedNumberFormatter::locale(const Locale& locale)&& {
+    return LocalizedNumberFormatter(std::move(fMacros), locale);
+}
+
+SymbolsWrapper::SymbolsWrapper(const SymbolsWrapper& other) {
     doCopyFrom(other);
 }
 
-SymbolsWrapper &SymbolsWrapper::operator=(const SymbolsWrapper &other) {
+SymbolsWrapper::SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT {
+    doMoveFrom(std::move(src));
+}
+
+SymbolsWrapper& SymbolsWrapper::operator=(const SymbolsWrapper& other) {
     if (this == &other) {
         return *this;
     }
@@ -192,23 +478,32 @@ SymbolsWrapper &SymbolsWrapper::operator=(const SymbolsWrapper &other) {
     return *this;
 }
 
+SymbolsWrapper& SymbolsWrapper::operator=(SymbolsWrapper&& src) U_NOEXCEPT {
+    if (this == &src) {
+        return *this;
+    }
+    doCleanup();
+    doMoveFrom(std::move(src));
+    return *this;
+}
+
 SymbolsWrapper::~SymbolsWrapper() {
     doCleanup();
 }
 
-void SymbolsWrapper::setTo(const DecimalFormatSymbols &dfs) {
+void SymbolsWrapper::setTo(const DecimalFormatSymbols& dfs) {
     doCleanup();
     fType = SYMPTR_DFS;
     fPtr.dfs = new DecimalFormatSymbols(dfs);
 }
 
-void SymbolsWrapper::setTo(const NumberingSystem *ns) {
+void SymbolsWrapper::setTo(const NumberingSystem* ns) {
     doCleanup();
     fType = SYMPTR_NS;
     fPtr.ns = ns;
 }
 
-void SymbolsWrapper::doCopyFrom(const SymbolsWrapper &other) {
+void SymbolsWrapper::doCopyFrom(const SymbolsWrapper& other) {
     fType = other.fType;
     switch (fType) {
         case SYMPTR_NONE:
@@ -233,6 +528,23 @@ void SymbolsWrapper::doCopyFrom(const SymbolsWrapper &other) {
     }
 }
 
+void SymbolsWrapper::doMoveFrom(SymbolsWrapper&& src) {
+    fType = src.fType;
+    switch (fType) {
+        case SYMPTR_NONE:
+            // No action necessary
+            break;
+        case SYMPTR_DFS:
+            fPtr.dfs = src.fPtr.dfs;
+            src.fPtr.dfs = nullptr;
+            break;
+        case SYMPTR_NS:
+            fPtr.ns = src.fPtr.ns;
+            src.fPtr.ns = nullptr;
+            break;
+    }
+}
+
 void SymbolsWrapper::doCleanup() {
     switch (fType) {
         case SYMPTR_NONE:
@@ -265,53 +577,122 @@ const NumberingSystem* SymbolsWrapper::getNumberingSystem() const {
     return fPtr.ns;
 }
 
-LocalizedNumberFormatter::~LocalizedNumberFormatter() {
-    delete fCompiled;
-}
 
-FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatInt(int64_t value, UErrorCode& status) const {
     if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
-    auto results = new NumberFormatterResults();
+    auto results = new UFormattedNumberData();
     if (results == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return FormattedNumber(status);
     }
     results->quantity.setToLong(value);
-    return formatImpl(results, status);
+    formatImpl(results, status);
+
+    // Do not save the results object if we encountered a failure.
+    if (U_SUCCESS(status)) {
+        return FormattedNumber(results);
+    } else {
+        delete results;
+        return FormattedNumber(status);
+    }
 }
 
-FormattedNumber LocalizedNumberFormatter::formatDouble(double value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatDouble(double value, UErrorCode& status) const {
     if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
-    auto results = new NumberFormatterResults();
+    auto results = new UFormattedNumberData();
     if (results == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return FormattedNumber(status);
     }
     results->quantity.setToDouble(value);
-    return formatImpl(results, status);
+    formatImpl(results, status);
+
+    // Do not save the results object if we encountered a failure.
+    if (U_SUCCESS(status)) {
+        return FormattedNumber(results);
+    } else {
+        delete results;
+        return FormattedNumber(status);
+    }
 }
 
-FormattedNumber LocalizedNumberFormatter::formatDecimal(StringPiece value, UErrorCode &status) const {
+FormattedNumber LocalizedNumberFormatter::formatDecimal(StringPiece value, UErrorCode& status) const {
     if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
-    auto results = new NumberFormatterResults();
+    auto results = new UFormattedNumberData();
     if (results == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return FormattedNumber(status);
     }
-    results->quantity.setToDecNumber(value);
-    return formatImpl(results, status);
+    results->quantity.setToDecNumber(value, status);
+    formatImpl(results, status);
+
+    // Do not save the results object if we encountered a failure.
+    if (U_SUCCESS(status)) {
+        return FormattedNumber(results);
+    } else {
+        delete results;
+        return FormattedNumber(status);
+    }
 }
 
 FormattedNumber
-LocalizedNumberFormatter::formatImpl(impl::NumberFormatterResults *results, UErrorCode &status) const {
+LocalizedNumberFormatter::formatDecimalQuantity(const DecimalQuantity& dq, UErrorCode& status) const {
+    if (U_FAILURE(status)) { return FormattedNumber(U_ILLEGAL_ARGUMENT_ERROR); }
+    auto results = new UFormattedNumberData();
+    if (results == nullptr) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return FormattedNumber(status);
+    }
+    results->quantity = dq;
+    formatImpl(results, status);
+
+    // Do not save the results object if we encountered a failure.
+    if (U_SUCCESS(status)) {
+        return FormattedNumber(results);
+    } else {
+        delete results;
+        return FormattedNumber(status);
+    }
+}
+
+void LocalizedNumberFormatter::formatImpl(impl::UFormattedNumberData* results, UErrorCode& status) const {
+    if (computeCompiled(status)) {
+        fCompiled->apply(results->quantity, results->string, status);
+    } else {
+        NumberFormatterImpl::applyStatic(fMacros, results->quantity, results->string, status);
+    }
+}
+
+void LocalizedNumberFormatter::getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result,
+                                            UErrorCode& status) const {
+    NumberStringBuilder string;
+    auto signum = static_cast<int8_t>(isNegative ? -1 : 1);
+    // Always return affixes for plural form OTHER.
+    static const StandardPlural::Form plural = StandardPlural::OTHER;
+    int32_t prefixLength;
+    if (computeCompiled(status)) {
+        prefixLength = fCompiled->getPrefixSuffix(signum, plural, string, status);
+    } else {
+        prefixLength = NumberFormatterImpl::getPrefixSuffixStatic(fMacros, signum, plural, string, status);
+    }
+    result.remove();
+    if (isPrefix) {
+        result.append(string.toTempUnicodeString().tempSubStringBetween(0, prefixLength));
+    } else {
+        result.append(string.toTempUnicodeString().tempSubStringBetween(prefixLength, string.length()));
+    }
+}
+
+bool LocalizedNumberFormatter::computeCompiled(UErrorCode& status) const {
     // fUnsafeCallCount contains memory to be interpreted as an atomic int, most commonly
     // std::atomic<int32_t>.  Since the type of atomic int is platform-dependent, we cast the
     // bytes in fUnsafeCallCount to u_atomic_int32_t, a typedef for the platform-dependent
     // atomic int type defined in umutex.h.
-    static_assert(sizeof(u_atomic_int32_t) <= sizeof(fUnsafeCallCount),
-        "Atomic integer size on this platform exceeds the size allocated by fUnsafeCallCount");
-    u_atomic_int32_t* callCount = reinterpret_cast<u_atomic_int32_t*>(
-        const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
+    static_assert(
+            sizeof(u_atomic_int32_t) <= sizeof(fUnsafeCallCount),
+            "Atomic integer size on this platform exceeds the size allocated by fUnsafeCallCount");
+    auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
+            const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
 
     // A positive value in the atomic int indicates that the data structure is not yet ready;
     // a negative value indicates that it is ready. If, after the increment, the atomic int
@@ -325,64 +706,144 @@ LocalizedNumberFormatter::formatImpl(impl::NumberFormatterResults *results, UErr
 
     if (currentCount == fMacros.threshold && fMacros.threshold > 0) {
         // Build the data structure and then use it (slow to fast path).
-        const NumberFormatterImpl* compiled =
-            NumberFormatterImpl::fromMacros(fMacros, status);
+        const NumberFormatterImpl* compiled = NumberFormatterImpl::fromMacros(fMacros, status);
         U_ASSERT(fCompiled == nullptr);
-        const_cast<LocalizedNumberFormatter *>(this)->fCompiled = compiled;
+        const_cast<LocalizedNumberFormatter*>(this)->fCompiled = compiled;
         umtx_storeRelease(*callCount, INT32_MIN);
-        compiled->apply(results->quantity, results->string, status);
+        return true;
     } else if (currentCount < 0) {
         // The data structure is already built; use it (fast path).
         U_ASSERT(fCompiled != nullptr);
-        fCompiled->apply(results->quantity, results->string, status);
+        return true;
     } else {
         // Format the number without building the data structure (slow path).
-        NumberFormatterImpl::applyStatic(fMacros, results->quantity, results->string, status);
+        return false;
     }
+}
 
-    // Do not save the results object if we encountered a failure.
-    if (U_SUCCESS(status)) {
-        return FormattedNumber(results);
-    } else {
-        delete results;
-        return FormattedNumber(status);
-    }
+const impl::NumberFormatterImpl* LocalizedNumberFormatter::getCompiled() const {
+    return fCompiled;
+}
+
+int32_t LocalizedNumberFormatter::getCallCount() const {
+    auto* callCount = reinterpret_cast<u_atomic_int32_t*>(
+            const_cast<LocalizedNumberFormatter*>(this)->fUnsafeCallCount);
+    return umtx_loadAcquire(*callCount);
+}
+
+Format* LocalizedNumberFormatter::toFormat(UErrorCode& status) const {
+    LocalPointer<LocalizedNumberFormatterAsFormat> retval(
+            new LocalizedNumberFormatterAsFormat(*this, fMacros.locale), status);
+    return retval.orphan();
+}
+
+
+FormattedNumber::FormattedNumber(FormattedNumber&& src) U_NOEXCEPT
+        : fResults(src.fResults), fErrorCode(src.fErrorCode) {
+    // Disown src.fResults to prevent double-deletion
+    src.fResults = nullptr;
+    src.fErrorCode = U_INVALID_STATE_ERROR;
+}
+
+FormattedNumber& FormattedNumber::operator=(FormattedNumber&& src) U_NOEXCEPT {
+    delete fResults;
+    fResults = src.fResults;
+    fErrorCode = src.fErrorCode;
+    // Disown src.fResults to prevent double-deletion
+    src.fResults = nullptr;
+    src.fErrorCode = U_INVALID_STATE_ERROR;
+    return *this;
 }
 
 UnicodeString FormattedNumber::toString() const {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    return toString(localStatus);
+}
+
+UnicodeString FormattedNumber::toString(UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return ICU_Utility::makeBogusString();
+    }
     if (fResults == nullptr) {
-        // TODO: http://bugs.icu-project.org/trac/ticket/13437
-        return {};
+        status = fErrorCode;
+        return ICU_Utility::makeBogusString();
     }
     return fResults->string.toUnicodeString();
 }
 
-Appendable &FormattedNumber::appendTo(Appendable &appendable) {
+Appendable& FormattedNumber::appendTo(Appendable& appendable) {
+    UErrorCode localStatus = U_ZERO_ERROR;
+    return appendTo(appendable, localStatus);
+}
+
+Appendable& FormattedNumber::appendTo(Appendable& appendable, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return appendable;
+    }
     if (fResults == nullptr) {
-        // TODO: http://bugs.icu-project.org/trac/ticket/13437
+        status = fErrorCode;
         return appendable;
     }
     appendable.appendString(fResults->string.chars(), fResults->string.length());
     return appendable;
 }
 
-void FormattedNumber::populateFieldPosition(FieldPosition &fieldPosition, UErrorCode &status) {
-    if (U_FAILURE(status)) { return; }
+void FormattedNumber::populateFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (fResults == nullptr) {
+        status = fErrorCode;
+        return;
+    }
+    // in case any users were depending on the old behavior:
+    fieldPosition.setBeginIndex(0);
+    fieldPosition.setEndIndex(0);
+    fResults->string.nextFieldPosition(fieldPosition, status);
+}
+
+UBool FormattedNumber::nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return FALSE;
+    }
+    if (fResults == nullptr) {
+        status = fErrorCode;
+        return FALSE;
+    }
+    // NOTE: MSVC sometimes complains when implicitly converting between bool and UBool
+    return fResults->string.nextFieldPosition(fieldPosition, status) ? TRUE : FALSE;
+}
+
+void FormattedNumber::populateFieldPositionIterator(FieldPositionIterator& iterator, UErrorCode& status) {
+    getAllFieldPositions(iterator, status);
+}
+
+void FormattedNumber::getAllFieldPositions(FieldPositionIterator& iterator, UErrorCode& status) const {
+    FieldPositionIteratorHandler fpih(&iterator, status);
+    getAllFieldPositionsImpl(fpih, status);
+}
+
+void FormattedNumber::getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpih,
+                                               UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return;
+    }
     if (fResults == nullptr) {
         status = fErrorCode;
         return;
     }
-    fResults->string.populateFieldPosition(fieldPosition, 0, status);
+    fResults->string.getAllFieldPositions(fpih, status);
 }
 
-void
-FormattedNumber::populateFieldPositionIterator(FieldPositionIterator &iterator, UErrorCode &status) {
-    if (U_FAILURE(status)) { return; }
+void FormattedNumber::getDecimalQuantity(DecimalQuantity& output, UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return;
+    }
     if (fResults == nullptr) {
         status = fErrorCode;
         return;
     }
-    fResults->string.populateFieldPositionIterator(iterator, status);
+    output = fResults->quantity;
 }
 
 FormattedNumber::~FormattedNumber() {
diff --git a/deps/icu-small/source/i18n/number_formatimpl.cpp b/deps/icu-small/source/i18n/number_formatimpl.cpp
index bc96cb15dabf90..3f887128bcc668 100644
--- a/deps/icu-small/source/i18n/number_formatimpl.cpp
+++ b/deps/icu-small/source/i18n/number_formatimpl.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "cstring.h"
 #include "unicode/ures.h"
@@ -26,88 +26,28 @@ using namespace icu::number::impl;
 
 namespace {
 
-// NOTE: In Java, the method to get a pattern from the resource bundle exists in NumberFormat.
-// In C++, we have to implement that logic here.
-// TODO: Make Java and C++ consistent?
-
-enum CldrPatternStyle {
-    CLDR_PATTERN_STYLE_DECIMAL,
-    CLDR_PATTERN_STYLE_CURRENCY,
-    CLDR_PATTERN_STYLE_ACCOUNTING,
-    CLDR_PATTERN_STYLE_PERCENT
-    // TODO: Consider scientific format.
-};
-
-const char16_t *
-doGetPattern(UResourceBundle *res, const char *nsName, const char *patternKey, UErrorCode &publicStatus,
-             UErrorCode &localStatus) {
-    // Construct the path into the resource bundle
-    CharString key;
-    key.append("NumberElements/", publicStatus);
-    key.append(nsName, publicStatus);
-    key.append("/patterns/", publicStatus);
-    key.append(patternKey, publicStatus);
-    if (U_FAILURE(publicStatus)) {
-        return u"";
-    }
-    return ures_getStringByKeyWithFallback(res, key.data(), nullptr, &localStatus);
-}
-
-const char16_t *getPatternForStyle(const Locale &locale, const char *nsName, CldrPatternStyle style,
-                                   UErrorCode &status) {
-    const char *patternKey;
-    switch (style) {
-        case CLDR_PATTERN_STYLE_DECIMAL:
-            patternKey = "decimalFormat";
-            break;
-        case CLDR_PATTERN_STYLE_CURRENCY:
-            patternKey = "currencyFormat";
-            break;
-        case CLDR_PATTERN_STYLE_ACCOUNTING:
-            patternKey = "accountingFormat";
-            break;
-        case CLDR_PATTERN_STYLE_PERCENT:
-        default:
-            patternKey = "percentFormat";
-            break;
-    }
-    LocalUResourceBundlePointer res(ures_open(nullptr, locale.getName(), &status));
-    if (U_FAILURE(status)) { return u""; }
-
-    // Attempt to get the pattern with the native numbering system.
-    UErrorCode localStatus = U_ZERO_ERROR;
-    const char16_t *pattern;
-    pattern = doGetPattern(res.getAlias(), nsName, patternKey, status, localStatus);
-    if (U_FAILURE(status)) { return u""; }
-
-    // Fall back to latn if native numbering system does not have the right pattern
-    if (U_FAILURE(localStatus) && uprv_strcmp("latn", nsName) != 0) {
-        localStatus = U_ZERO_ERROR;
-        pattern = doGetPattern(res.getAlias(), "latn", patternKey, status, localStatus);
-        if (U_FAILURE(status)) { return u""; }
-    }
-
-    return pattern;
-}
-
 struct CurrencyFormatInfoResult {
     bool exists;
     const char16_t* pattern;
     const char16_t* decimalSeparator;
     const char16_t* groupingSeparator;
 };
-CurrencyFormatInfoResult getCurrencyFormatInfo(const Locale& locale, const char* isoCode, UErrorCode& status) {
+
+CurrencyFormatInfoResult
+getCurrencyFormatInfo(const Locale& locale, const char* isoCode, UErrorCode& status) {
     // TODO: Load this data in a centralized location like ICU4J?
+    // TODO: Move this into the CurrencySymbols class?
     // TODO: Parts of this same data are loaded in dcfmtsym.cpp; should clean up.
-    CurrencyFormatInfoResult result = { false, nullptr, nullptr, nullptr };
-    if (U_FAILURE(status)) return result;
+    CurrencyFormatInfoResult result = {false, nullptr, nullptr, nullptr};
+    if (U_FAILURE(status)) { return result; }
     CharString key;
     key.append("Currencies/", status);
     key.append(isoCode, status);
     UErrorCode localStatus = status;
     LocalUResourceBundlePointer bundle(ures_open(U_ICUDATA_CURR, locale.getName(), &localStatus));
     ures_getByKeyWithFallback(bundle.getAlias(), key.data(), bundle.getAlias(), &localStatus);
-    if (U_SUCCESS(localStatus) && ures_getSize(bundle.getAlias())>2) { // the length is 3 if more data is present
+    if (U_SUCCESS(localStatus) &&
+        ures_getSize(bundle.getAlias()) > 2) { // the length is 3 if more data is present
         ures_getByIndex(bundle.getAlias(), 2, bundle.getAlias(), &localStatus);
         int32_t dummy;
         result.exists = true;
@@ -121,65 +61,84 @@ CurrencyFormatInfoResult getCurrencyFormatInfo(const Locale& locale, const char*
     return result;
 }
 
-inline bool unitIsCurrency(const MeasureUnit &unit) {
-    return uprv_strcmp("currency", unit.getType()) == 0;
-}
-
-inline bool unitIsNoUnit(const MeasureUnit &unit) {
-    return uprv_strcmp("none", unit.getType()) == 0;
-}
+}  // namespace
 
-inline bool unitIsPercent(const MeasureUnit &unit) {
-    return uprv_strcmp("percent", unit.getSubtype()) == 0;
-}
 
-inline bool unitIsPermille(const MeasureUnit &unit) {
-    return uprv_strcmp("permille", unit.getSubtype()) == 0;
-}
+MicroPropsGenerator::~MicroPropsGenerator() = default;
 
-}  // namespace
 
-NumberFormatterImpl *NumberFormatterImpl::fromMacros(const MacroProps &macros, UErrorCode &status) {
+NumberFormatterImpl* NumberFormatterImpl::fromMacros(const MacroProps& macros, UErrorCode& status) {
     return new NumberFormatterImpl(macros, true, status);
 }
 
-void NumberFormatterImpl::applyStatic(const MacroProps &macros, DecimalQuantity &inValue,
-                                      NumberStringBuilder &outString, UErrorCode &status) {
+void NumberFormatterImpl::applyStatic(const MacroProps& macros, DecimalQuantity& inValue,
+                                      NumberStringBuilder& outString, UErrorCode& status) {
     NumberFormatterImpl impl(macros, false, status);
     impl.applyUnsafe(inValue, outString, status);
 }
 
+int32_t NumberFormatterImpl::getPrefixSuffixStatic(const MacroProps& macros, int8_t signum,
+                                                   StandardPlural::Form plural,
+                                                   NumberStringBuilder& outString, UErrorCode& status) {
+    NumberFormatterImpl impl(macros, false, status);
+    return impl.getPrefixSuffixUnsafe(signum, plural, outString, status);
+}
+
 // NOTE: C++ SPECIFIC DIFFERENCE FROM JAVA:
 // The "safe" apply method uses a new MicroProps. In the MicroPropsGenerator, fMicros is copied into the new instance.
 // The "unsafe" method simply re-uses fMicros, eliminating the extra copy operation.
 // See MicroProps::processQuantity() for details.
 
-void NumberFormatterImpl::apply(DecimalQuantity &inValue, NumberStringBuilder &outString,
-                                UErrorCode &status) const {
+void NumberFormatterImpl::apply(DecimalQuantity& inValue, NumberStringBuilder& outString,
+                                UErrorCode& status) const {
     if (U_FAILURE(status)) { return; }
     MicroProps micros;
+    if (!fMicroPropsGenerator) { return; }
     fMicroPropsGenerator->processQuantity(inValue, micros, status);
     if (U_FAILURE(status)) { return; }
     microsToString(micros, inValue, outString, status);
 }
 
-void NumberFormatterImpl::applyUnsafe(DecimalQuantity &inValue, NumberStringBuilder &outString,
-                                      UErrorCode &status) {
+void NumberFormatterImpl::applyUnsafe(DecimalQuantity& inValue, NumberStringBuilder& outString,
+                                      UErrorCode& status) {
     if (U_FAILURE(status)) { return; }
     fMicroPropsGenerator->processQuantity(inValue, fMicros, status);
     if (U_FAILURE(status)) { return; }
     microsToString(fMicros, inValue, outString, status);
 }
 
-NumberFormatterImpl::NumberFormatterImpl(const MacroProps &macros, bool safe, UErrorCode &status) {
+int32_t NumberFormatterImpl::getPrefixSuffix(int8_t signum, StandardPlural::Form plural,
+                                             NumberStringBuilder& outString, UErrorCode& status) const {
+    if (U_FAILURE(status)) { return 0; }
+    // #13453: DecimalFormat wants the affixes from the pattern only (modMiddle, aka pattern modifier).
+    // Safe path: use fImmutablePatternModifier.
+    const Modifier* modifier = fImmutablePatternModifier->getModifier(signum, plural);
+    modifier->apply(outString, 0, 0, status);
+    if (U_FAILURE(status)) { return 0; }
+    return modifier->getPrefixLength(status);
+}
+
+int32_t NumberFormatterImpl::getPrefixSuffixUnsafe(int8_t signum, StandardPlural::Form plural,
+                                                   NumberStringBuilder& outString, UErrorCode& status) {
+    if (U_FAILURE(status)) { return 0; }
+    // #13453: DecimalFormat wants the affixes from the pattern only (modMiddle, aka pattern modifier).
+    // Unsafe path: use fPatternModifier.
+    fPatternModifier->setNumberProperties(signum, plural);
+    fPatternModifier->apply(outString, 0, 0, status);
+    if (U_FAILURE(status)) { return 0; }
+    return fPatternModifier->getPrefixLength(status);
+}
+
+NumberFormatterImpl::NumberFormatterImpl(const MacroProps& macros, bool safe, UErrorCode& status) {
     fMicroPropsGenerator = macrosToMicroGenerator(macros, safe, status);
 }
 
 //////////
 
-const MicroPropsGenerator *
-NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe, UErrorCode &status) {
-    const MicroPropsGenerator *chain = &fMicros;
+const MicroPropsGenerator*
+NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe, UErrorCode& status) {
+    if (U_FAILURE(status)) { return nullptr; }
+    const MicroPropsGenerator* chain = &fMicros;
 
     // Check that macros is error-free before continuing.
     if (macros.copyErrorTo(status)) {
@@ -189,18 +148,26 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     // TODO: Accept currency symbols from DecimalFormatSymbols?
 
     // Pre-compute a few values for efficiency.
-    bool isCurrency = unitIsCurrency(macros.unit);
-    bool isNoUnit = unitIsNoUnit(macros.unit);
-    bool isPercent = isNoUnit && unitIsPercent(macros.unit);
-    bool isPermille = isNoUnit && unitIsPermille(macros.unit);
+    bool isCurrency = utils::unitIsCurrency(macros.unit);
+    bool isNoUnit = utils::unitIsNoUnit(macros.unit);
+    bool isPercent = isNoUnit && utils::unitIsPercent(macros.unit);
+    bool isPermille = isNoUnit && utils::unitIsPermille(macros.unit);
     bool isCldrUnit = !isCurrency && !isNoUnit;
-    bool isAccounting = macros.sign == UNUM_SIGN_ACCOUNTING
-            || macros.sign == UNUM_SIGN_ACCOUNTING_ALWAYS
-            || macros.sign == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
-    CurrencyUnit currency(kDefaultCurrency, status);
+    bool isAccounting =
+            macros.sign == UNUM_SIGN_ACCOUNTING || macros.sign == UNUM_SIGN_ACCOUNTING_ALWAYS ||
+            macros.sign == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
+    CurrencyUnit currency(nullptr, status);
     if (isCurrency) {
         currency = CurrencyUnit(macros.unit, status); // Restore CurrencyUnit from MeasureUnit
     }
+    const CurrencySymbols* currencySymbols;
+    if (macros.currencySymbols != nullptr) {
+        // Used by the DecimalFormat code path
+        currencySymbols = macros.currencySymbols;
+    } else {
+        fWarehouse.fCurrencySymbols = {currency, macros.locale, status};
+        currencySymbols = &fWarehouse.fCurrencySymbols;
+    }
     UNumberUnitWidth unitWidth = UNUM_UNIT_WIDTH_SHORT;
     if (macros.unitWidth != UNUM_UNIT_WIDTH_COUNT) {
         unitWidth = macros.unitWidth;
@@ -208,7 +175,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
 
     // Select the numbering system.
     LocalPointer<const NumberingSystem> nsLocal;
-    const NumberingSystem *ns;
+    const NumberingSystem* ns;
     if (macros.symbols.isNumberingSystem()) {
         ns = macros.symbols.getNumberingSystem();
     } else {
@@ -217,7 +184,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
         // Give ownership to the function scope.
         nsLocal.adoptInstead(ns);
     }
-    const char *nsName = U_SUCCESS(status) ? ns->getName() : "latn";
+    const char* nsName = U_SUCCESS(status) ? ns->getName() : "latn";
 
     // Resolve the symbols. Do this here because currency may need to customize them.
     if (macros.symbols.isDecimalFormatSymbols()) {
@@ -232,21 +199,22 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     // If we are formatting currency, check for a currency-specific pattern.
     const char16_t* pattern = nullptr;
     if (isCurrency) {
-        CurrencyFormatInfoResult info = getCurrencyFormatInfo(macros.locale, currency.getSubtype(), status);
+        CurrencyFormatInfoResult info = getCurrencyFormatInfo(
+                macros.locale, currency.getSubtype(), status);
         if (info.exists) {
             pattern = info.pattern;
             // It's clunky to clone an object here, but this code is not frequently executed.
-            DecimalFormatSymbols* symbols = new DecimalFormatSymbols(*fMicros.symbols);
+            auto* symbols = new DecimalFormatSymbols(*fMicros.symbols);
             fMicros.symbols = symbols;
             fSymbols.adoptInstead(symbols);
             symbols->setSymbol(
-                DecimalFormatSymbols::ENumberFormatSymbol::kMonetarySeparatorSymbol,
-                UnicodeString(info.decimalSeparator),
-                FALSE);
+                    DecimalFormatSymbols::ENumberFormatSymbol::kMonetarySeparatorSymbol,
+                    UnicodeString(info.decimalSeparator),
+                    FALSE);
             symbols->setSymbol(
-                DecimalFormatSymbols::ENumberFormatSymbol::kMonetaryGroupingSeparatorSymbol,
-                UnicodeString(info.groupingSeparator),
-                FALSE);
+                    DecimalFormatSymbols::ENumberFormatSymbol::kMonetaryGroupingSeparatorSymbol,
+                    UnicodeString(info.groupingSeparator),
+                    FALSE);
         }
     }
     if (pattern == nullptr) {
@@ -262,7 +230,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
         } else {
             patternStyle = CLDR_PATTERN_STYLE_CURRENCY;
         }
-        pattern = getPatternForStyle(macros.locale, nsName, patternStyle, status);
+        pattern = utils::getPatternForStyle(macros.locale, nsName, patternStyle, status);
     }
     auto patternInfo = new ParsedPatternInfo();
     fPatternInfo.adoptInstead(patternInfo);
@@ -272,17 +240,31 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     /// START POPULATING THE DEFAULT MICROPROPS AND BUILDING THE MICROPROPS GENERATOR ///
     /////////////////////////////////////////////////////////////////////////////////////
 
+    // Multiplier
+    if (macros.scale.isValid()) {
+        fMicros.helpers.multiplier.setAndChain(macros.scale, chain);
+        chain = &fMicros.helpers.multiplier;
+    }
+
     // Rounding strategy
-    if (!macros.rounder.isBogus()) {
-        fMicros.rounding = macros.rounder;
+    Precision precision;
+    if (!macros.precision.isBogus()) {
+        precision = macros.precision;
     } else if (macros.notation.fType == Notation::NTN_COMPACT) {
-        fMicros.rounding = Rounder::integer().withMinDigits(2);
+        precision = Precision::integer().withMinDigits(2);
     } else if (isCurrency) {
-        fMicros.rounding = Rounder::currency(UCURR_USAGE_STANDARD);
+        precision = Precision::currency(UCURR_USAGE_STANDARD);
+    } else {
+        precision = Precision::maxFraction(6);
+    }
+    UNumberFormatRoundingMode roundingMode;
+    if (macros.roundingMode != kDefaultMode) {
+        roundingMode = macros.roundingMode;
     } else {
-        fMicros.rounding = Rounder::maxFraction(6);
+        // Temporary until ICU 64
+        roundingMode = precision.fRoundingMode;
     }
-    fMicros.rounding.setLocaleData(currency, status);
+    fMicros.rounder = {precision, roundingMode, currency, status};
 
     // Grouping strategy
     if (!macros.grouper.isBogus()) {
@@ -306,7 +288,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     if (!macros.integerWidth.isBogus()) {
         fMicros.integerWidth = macros.integerWidth;
     } else {
-        fMicros.integerWidth = IntegerWidth::zeroFillTo(1);
+        fMicros.integerWidth = IntegerWidth::standard();
     }
 
     // Sign display
@@ -338,16 +320,18 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     // Middle modifier (patterns, positive/negative, currency symbols, percent)
     auto patternModifier = new MutablePatternModifier(false);
     fPatternModifier.adoptInstead(patternModifier);
-    patternModifier->setPatternInfo(fPatternInfo.getAlias());
+    patternModifier->setPatternInfo(
+            macros.affixProvider != nullptr ? macros.affixProvider
+                                            : static_cast<const AffixPatternProvider*>(fPatternInfo.getAlias()));
     patternModifier->setPatternAttributes(fMicros.sign, isPermille);
     if (patternModifier->needsPlurals()) {
         patternModifier->setSymbols(
                 fMicros.symbols,
-                currency,
+                currencySymbols,
                 unitWidth,
                 resolvePluralRules(macros.rules, macros.locale, status));
     } else {
-        patternModifier->setSymbols(fMicros.symbols, currency, unitWidth, nullptr);
+        patternModifier->setSymbols(fMicros.symbols, currencySymbols, unitWidth, nullptr);
     }
     if (safe) {
         fImmutablePatternModifier.adoptInstead(patternModifier->createImmutableAndChain(chain, status));
@@ -407,9 +391,9 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps &macros, bool safe,
     return chain;
 }
 
-const PluralRules *
-NumberFormatterImpl::resolvePluralRules(const PluralRules *rulesPtr, const Locale &locale,
-                                        UErrorCode &status) {
+const PluralRules*
+NumberFormatterImpl::resolvePluralRules(const PluralRules* rulesPtr, const Locale& locale,
+                                        UErrorCode& status) {
     if (rulesPtr != nullptr) {
         return rulesPtr;
     }
@@ -420,9 +404,9 @@ NumberFormatterImpl::resolvePluralRules(const PluralRules *rulesPtr, const Local
     return fRules.getAlias();
 }
 
-int32_t NumberFormatterImpl::microsToString(const MicroProps &micros, DecimalQuantity &quantity,
-                                            NumberStringBuilder &string, UErrorCode &status) {
-    micros.rounding.apply(quantity, status);
+int32_t NumberFormatterImpl::microsToString(const MicroProps& micros, DecimalQuantity& quantity,
+                                            NumberStringBuilder& string, UErrorCode& status) {
+    micros.rounder.apply(quantity, status);
     micros.integerWidth.apply(quantity, status);
     int32_t length = writeNumber(micros, quantity, string, status);
     // NOTE: When range formatting is added, these modifiers can bubble up.
@@ -439,8 +423,8 @@ int32_t NumberFormatterImpl::microsToString(const MicroProps &micros, DecimalQua
     return length;
 }
 
-int32_t NumberFormatterImpl::writeNumber(const MicroProps &micros, DecimalQuantity &quantity,
-                                         NumberStringBuilder &string, UErrorCode &status) {
+int32_t NumberFormatterImpl::writeNumber(const MicroProps& micros, DecimalQuantity& quantity,
+                                         NumberStringBuilder& string, UErrorCode& status) {
     int32_t length = 0;
     if (quantity.isInfinite()) {
         length += string.insert(
@@ -480,8 +464,8 @@ int32_t NumberFormatterImpl::writeNumber(const MicroProps &micros, DecimalQuanti
     return length;
 }
 
-int32_t NumberFormatterImpl::writeIntegerDigits(const MicroProps &micros, DecimalQuantity &quantity,
-                                                NumberStringBuilder &string, UErrorCode &status) {
+int32_t NumberFormatterImpl::writeIntegerDigits(const MicroProps& micros, DecimalQuantity& quantity,
+                                                NumberStringBuilder& string, UErrorCode& status) {
     int length = 0;
     int integerCount = quantity.getUpperDisplayMagnitude() + 1;
     for (int i = 0; i < integerCount; i++) {
@@ -499,21 +483,21 @@ int32_t NumberFormatterImpl::writeIntegerDigits(const MicroProps &micros, Decima
 
         // Get and append the next digit value
         int8_t nextDigit = quantity.getDigit(i);
-        length += string.insert(
-                0, getDigitFromSymbols(nextDigit, *micros.symbols), UNUM_INTEGER_FIELD, status);
+        length += utils::insertDigitFromSymbols(
+                string, 0, nextDigit, *micros.symbols, UNUM_INTEGER_FIELD, status);
     }
     return length;
 }
 
-int32_t NumberFormatterImpl::writeFractionDigits(const MicroProps &micros, DecimalQuantity &quantity,
-                                                 NumberStringBuilder &string, UErrorCode &status) {
+int32_t NumberFormatterImpl::writeFractionDigits(const MicroProps& micros, DecimalQuantity& quantity,
+                                                 NumberStringBuilder& string, UErrorCode& status) {
     int length = 0;
     int fractionCount = -quantity.getLowerDisplayMagnitude();
     for (int i = 0; i < fractionCount; i++) {
         // Get and append the next digit value
         int8_t nextDigit = quantity.getDigit(-i - 1);
-        length += string.append(
-                getDigitFromSymbols(nextDigit, *micros.symbols), UNUM_FRACTION_FIELD, status);
+        length += utils::insertDigitFromSymbols(
+                string, string.length(), nextDigit, *micros.symbols, UNUM_FRACTION_FIELD, status);
     }
     return length;
 }
diff --git a/deps/icu-small/source/i18n/number_formatimpl.h b/deps/icu-small/source/i18n/number_formatimpl.h
index cbc04ba30df4c4..744fecec13f984 100644
--- a/deps/icu-small/source/i18n/number_formatimpl.h
+++ b/deps/icu-small/source/i18n/number_formatimpl.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_FORMATIMPL_H__
 #define __NUMBER_FORMATIMPL_H__
 
@@ -14,6 +14,7 @@
 #include "number_patternmodifier.h"
 #include "number_longnames.h"
 #include "number_compact.h"
+#include "number_microprops.h"
 
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
@@ -37,10 +38,26 @@ class NumberFormatterImpl : public UMemory {
     applyStatic(const MacroProps &macros, DecimalQuantity &inValue, NumberStringBuilder &outString,
                 UErrorCode &status);
 
+    /**
+     * Prints only the prefix and suffix; used for DecimalFormat getters.
+     *
+     * @return The index into the output at which the prefix ends and the suffix starts; in other words,
+     *         the prefix length.
+     */
+    static int32_t getPrefixSuffixStatic(const MacroProps& macros, int8_t signum,
+                                         StandardPlural::Form plural, NumberStringBuilder& outString,
+                                         UErrorCode& status);
+
     /**
      * Evaluates the "safe" MicroPropsGenerator created by "fromMacros".
      */
-    void apply(DecimalQuantity &inValue, NumberStringBuilder &outString, UErrorCode &status) const;
+    void apply(DecimalQuantity& inValue, NumberStringBuilder& outString, UErrorCode& status) const;
+
+    /**
+     * Like getPrefixSuffixStatic() but uses the safe compiled object.
+     */
+    int32_t getPrefixSuffix(int8_t signum, StandardPlural::Form plural, NumberStringBuilder& outString,
+                            UErrorCode& status) const;
 
   private:
     // Head of the MicroPropsGenerator linked list:
@@ -50,21 +67,29 @@ class NumberFormatterImpl : public UMemory {
     MicroProps fMicros;
 
     // Other fields possibly used by the number formatting pipeline:
-    // TODO: Convert some of these LocalPointers to value objects to reduce the number of news?
+    // TODO: Convert more of these LocalPointers to value objects to reduce the number of news?
     LocalPointer<const DecimalFormatSymbols> fSymbols;
     LocalPointer<const PluralRules> fRules;
     LocalPointer<const ParsedPatternInfo> fPatternInfo;
     LocalPointer<const ScientificHandler> fScientificHandler;
-    LocalPointer<const MutablePatternModifier> fPatternModifier;
+    LocalPointer<MutablePatternModifier> fPatternModifier;
     LocalPointer<const ImmutablePatternModifier> fImmutablePatternModifier;
     LocalPointer<const LongNameHandler> fLongNameHandler;
     LocalPointer<const CompactHandler> fCompactHandler;
 
+    // Value objects possibly used by the number formatting pipeline:
+    struct Warehouse {
+        CurrencySymbols fCurrencySymbols;
+    } fWarehouse;
+
 
     NumberFormatterImpl(const MacroProps &macros, bool safe, UErrorCode &status);
 
     void applyUnsafe(DecimalQuantity &inValue, NumberStringBuilder &outString, UErrorCode &status);
 
+    int32_t getPrefixSuffixUnsafe(int8_t signum, StandardPlural::Form plural,
+                                  NumberStringBuilder& outString, UErrorCode& status);
+
     /**
      * If rulesPtr is non-null, return it.  Otherwise, return a PluralRules owned by this object for the
      * specified locale, creating it if necessary.
diff --git a/deps/icu-small/source/i18n/number_grouping.cpp b/deps/icu-small/source/i18n/number_grouping.cpp
index a2b1bbd6b3388e..4a1cceb49948b9 100644
--- a/deps/icu-small/source/i18n/number_grouping.cpp
+++ b/deps/icu-small/source/i18n/number_grouping.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "unicode/numberformatter.h"
 #include "number_patternstring.h"
@@ -37,20 +37,33 @@ int16_t getMinGroupingForLocale(const Locale& locale) {
 Grouper Grouper::forStrategy(UGroupingStrategy grouping) {
     switch (grouping) {
     case UNUM_GROUPING_OFF:
-        return {-1, -1, -2};
+        return {-1, -1, -2, grouping};
     case UNUM_GROUPING_AUTO:
-        return {-2, -2, -2};
+        return {-2, -2, -2, grouping};
     case UNUM_GROUPING_MIN2:
-        return {-2, -2, -3};
+        return {-2, -2, -3, grouping};
     case UNUM_GROUPING_ON_ALIGNED:
-        return {-4, -4, 1};
+        return {-4, -4, 1, grouping};
     case UNUM_GROUPING_THOUSANDS:
-        return {3, 3, 1};
+        return {3, 3, 1, grouping};
     default:
         U_ASSERT(FALSE);
+        return {}; // return a value: silence compiler warning
     }
 }
 
+Grouper Grouper::forProperties(const DecimalFormatProperties& properties) {
+    if (!properties.groupingUsed) {
+        return forStrategy(UNUM_GROUPING_OFF);
+    }
+    auto grouping1 = static_cast<int16_t>(properties.groupingSize);
+    auto grouping2 = static_cast<int16_t>(properties.secondaryGroupingSize);
+    auto minGrouping = static_cast<int16_t>(properties.minimumGroupingDigits);
+    grouping1 = grouping1 > 0 ? grouping1 : grouping2 > 0 ? grouping2 : grouping1;
+    grouping2 = grouping2 > 0 ? grouping2 : grouping1;
+    return {grouping1, grouping2, minGrouping, UNUM_GROUPING_COUNT};
+}
+
 void Grouper::setLocaleData(const impl::ParsedPatternInfo &patternInfo, const Locale& locale) {
     if (fGrouping1 != -2 && fGrouping2 != -4) {
         return;
@@ -86,4 +99,12 @@ bool Grouper::groupAtPosition(int32_t position, const impl::DecimalQuantity &val
            && value.getUpperDisplayMagnitude() - fGrouping1 + 1 >= fMinGrouping;
 }
 
+int16_t Grouper::getPrimary() const {
+    return fGrouping1;
+}
+
+int16_t Grouper::getSecondary() const {
+    return fGrouping2;
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_integerwidth.cpp b/deps/icu-small/source/i18n/number_integerwidth.cpp
index 4a612273f5e530..6416b292982e56 100644
--- a/deps/icu-small/source/i18n/number_integerwidth.cpp
+++ b/deps/icu-small/source/i18n/number_integerwidth.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "unicode/numberformatter.h"
 #include "number_types.h"
@@ -13,14 +13,15 @@ using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
-IntegerWidth::IntegerWidth(digits_t minInt, digits_t maxInt) {
+IntegerWidth::IntegerWidth(digits_t minInt, digits_t maxInt, bool formatFailIfMoreThanMaxDigits) {
     fUnion.minMaxInt.fMinInt = minInt;
     fUnion.minMaxInt.fMaxInt = maxInt;
+    fUnion.minMaxInt.fFormatFailIfMoreThanMaxDigits = formatFailIfMoreThanMaxDigits;
 }
 
 IntegerWidth IntegerWidth::zeroFillTo(int32_t minInt) {
     if (minInt >= 0 && minInt <= kMaxIntFracSig) {
-        return {static_cast<digits_t>(minInt), -1};
+        return {static_cast<digits_t>(minInt), -1, false};
     } else {
         return {U_NUMBER_ARG_OUTOFBOUNDS_ERROR};
     }
@@ -30,22 +31,37 @@ IntegerWidth IntegerWidth::truncateAt(int32_t maxInt) {
     if (fHasError) { return *this; }  // No-op on error
     digits_t minInt = fUnion.minMaxInt.fMinInt;
     if (maxInt >= 0 && maxInt <= kMaxIntFracSig && minInt <= maxInt) {
-        return {minInt, static_cast<digits_t>(maxInt)};
+        return {minInt, static_cast<digits_t>(maxInt), false};
     } else if (maxInt == -1) {
-        return {minInt, -1};
+        return {minInt, -1, false};
     } else {
         return {U_NUMBER_ARG_OUTOFBOUNDS_ERROR};
     }
 }
 
-void IntegerWidth::apply(impl::DecimalQuantity &quantity, UErrorCode &status) const {
+void IntegerWidth::apply(impl::DecimalQuantity& quantity, UErrorCode& status) const {
     if (fHasError) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
     } else if (fUnion.minMaxInt.fMaxInt == -1) {
         quantity.setIntegerLength(fUnion.minMaxInt.fMinInt, INT32_MAX);
     } else {
+        // Enforce the backwards-compatibility feature "FormatFailIfMoreThanMaxDigits"
+        if (fUnion.minMaxInt.fFormatFailIfMoreThanMaxDigits &&
+            fUnion.minMaxInt.fMaxInt < quantity.getMagnitude()) {
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+        }
         quantity.setIntegerLength(fUnion.minMaxInt.fMinInt, fUnion.minMaxInt.fMaxInt);
     }
 }
 
+bool IntegerWidth::operator==(const IntegerWidth& other) const {
+    // Private operator==; do error and bogus checking first!
+    U_ASSERT(!fHasError);
+    U_ASSERT(!other.fHasError);
+    U_ASSERT(!isBogus());
+    U_ASSERT(!other.isBogus());
+    return fUnion.minMaxInt.fMinInt == other.fUnion.minMaxInt.fMinInt &&
+           fUnion.minMaxInt.fMaxInt == other.fUnion.minMaxInt.fMaxInt;
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_longnames.cpp b/deps/icu-small/source/i18n/number_longnames.cpp
index 5c363442e7c033..26f9af4c9bdbfe 100644
--- a/deps/icu-small/source/i18n/number_longnames.cpp
+++ b/deps/icu-small/source/i18n/number_longnames.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "unicode/simpleformatter.h"
 #include "unicode/ures.h"
@@ -11,6 +11,7 @@
 #include "charstr.h"
 #include "uresimp.h"
 #include "number_longnames.h"
+#include "number_microprops.h"
 #include <algorithm>
 #include "cstring.h"
 
@@ -260,8 +261,8 @@ void LongNameHandler::processQuantity(DecimalQuantity &quantity, MicroProps &mic
     parent->processQuantity(quantity, micros, status);
     // TODO: Avoid the copy here?
     DecimalQuantity copy(quantity);
-    micros.rounding.apply(copy, status);
-    micros.modOuter = &fModifiers[copy.getStandardPlural(rules)];
+    micros.rounder.apply(copy, status);
+    micros.modOuter = &fModifiers[utils::getStandardPlural(rules, copy)];
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_longnames.h b/deps/icu-small/source/i18n/number_longnames.h
index 8738bb99e7d2e6..1d1e7dd3e864a6 100644
--- a/deps/icu-small/source/i18n/number_longnames.h
+++ b/deps/icu-small/source/i18n/number_longnames.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_LONGNAMES_H__
 #define __NUMBER_LONGNAMES_H__
 
diff --git a/deps/icu-small/source/i18n/number_mapper.cpp b/deps/icu-small/source/i18n/number_mapper.cpp
new file mode 100644
index 00000000000000..d260632f93b0db
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_mapper.cpp
@@ -0,0 +1,502 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "number_mapper.h"
+#include "number_patternstring.h"
+#include "unicode/errorcode.h"
+#include "number_utils.h"
+#include "number_currencysymbols.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+
+UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
+                                                        const DecimalFormatSymbols& symbols,
+                                                        DecimalFormatWarehouse& warehouse,
+                                                        UErrorCode& status) {
+    return NumberFormatter::with().macros(oldToNew(properties, symbols, warehouse, nullptr, status));
+}
+
+UnlocalizedNumberFormatter NumberPropertyMapper::create(const DecimalFormatProperties& properties,
+                                                        const DecimalFormatSymbols& symbols,
+                                                        DecimalFormatWarehouse& warehouse,
+                                                        DecimalFormatProperties& exportedProperties,
+                                                        UErrorCode& status) {
+    return NumberFormatter::with().macros(
+            oldToNew(
+                    properties, symbols, warehouse, &exportedProperties, status));
+}
+
+MacroProps NumberPropertyMapper::oldToNew(const DecimalFormatProperties& properties,
+                                          const DecimalFormatSymbols& symbols,
+                                          DecimalFormatWarehouse& warehouse,
+                                          DecimalFormatProperties* exportedProperties,
+                                          UErrorCode& status) {
+    MacroProps macros;
+    Locale locale = symbols.getLocale();
+
+    /////////////
+    // SYMBOLS //
+    /////////////
+
+    macros.symbols.setTo(symbols);
+
+    //////////////////
+    // PLURAL RULES //
+    //////////////////
+
+    if (!properties.currencyPluralInfo.fPtr.isNull()) {
+        macros.rules = properties.currencyPluralInfo.fPtr->getPluralRules();
+    }
+
+    /////////////
+    // AFFIXES //
+    /////////////
+
+    AffixPatternProvider* affixProvider;
+    if (properties.currencyPluralInfo.fPtr.isNull()) {
+        warehouse.currencyPluralInfoAPP.setToBogus();
+        warehouse.propertiesAPP.setTo(properties, status);
+        affixProvider = &warehouse.propertiesAPP;
+    } else {
+        warehouse.currencyPluralInfoAPP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
+        warehouse.propertiesAPP.setToBogus();
+        affixProvider = &warehouse.currencyPluralInfoAPP;
+    }
+    macros.affixProvider = affixProvider;
+
+    ///////////
+    // UNITS //
+    ///////////
+
+    bool useCurrency = (
+            !properties.currency.isNull() || !properties.currencyPluralInfo.fPtr.isNull() ||
+            !properties.currencyUsage.isNull() || affixProvider->hasCurrencySign());
+    CurrencyUnit currency = resolveCurrency(properties, locale, status);
+    UCurrencyUsage currencyUsage = properties.currencyUsage.getOrDefault(UCURR_USAGE_STANDARD);
+    if (useCurrency) {
+        // NOTE: Slicing is OK.
+        macros.unit = currency; // NOLINT
+    }
+    warehouse.currencySymbols = {currency, locale, symbols, status};
+    macros.currencySymbols = &warehouse.currencySymbols;
+
+    ///////////////////////
+    // ROUNDING STRATEGY //
+    ///////////////////////
+
+    int32_t maxInt = properties.maximumIntegerDigits;
+    int32_t minInt = properties.minimumIntegerDigits;
+    int32_t maxFrac = properties.maximumFractionDigits;
+    int32_t minFrac = properties.minimumFractionDigits;
+    int32_t minSig = properties.minimumSignificantDigits;
+    int32_t maxSig = properties.maximumSignificantDigits;
+    double roundingIncrement = properties.roundingIncrement;
+    RoundingMode roundingMode = properties.roundingMode.getOrDefault(UNUM_ROUND_HALFEVEN);
+    bool explicitMinMaxFrac = minFrac != -1 || maxFrac != -1;
+    bool explicitMinMaxSig = minSig != -1 || maxSig != -1;
+    // Resolve min/max frac for currencies, required for the validation logic and for when minFrac or
+    // maxFrac was
+    // set (but not both) on a currency instance.
+    // NOTE: Increments are handled in "Precision.constructCurrency()".
+    if (useCurrency && (minFrac == -1 || maxFrac == -1)) {
+        int32_t digits = ucurr_getDefaultFractionDigitsForUsage(
+                currency.getISOCurrency(), currencyUsage, &status);
+        if (minFrac == -1 && maxFrac == -1) {
+            minFrac = digits;
+            maxFrac = digits;
+        } else if (minFrac == -1) {
+            minFrac = std::min(maxFrac, digits);
+        } else /* if (maxFrac == -1) */ {
+            maxFrac = std::max(minFrac, digits);
+        }
+    }
+    // Validate min/max int/frac.
+    // For backwards compatibility, minimum overrides maximum if the two conflict.
+    // The following logic ensures that there is always a minimum of at least one digit.
+    if (minInt == 0 && maxFrac != 0) {
+        // Force a digit after the decimal point.
+        minFrac = minFrac <= 0 ? 1 : minFrac;
+        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
+        minInt = 0;
+        maxInt = maxInt < 0 ? -1 : maxInt > kMaxIntFracSig ? -1 : maxInt;
+    } else {
+        // Force a digit before the decimal point.
+        minFrac = minFrac < 0 ? 0 : minFrac;
+        maxFrac = maxFrac < 0 ? -1 : maxFrac < minFrac ? minFrac : maxFrac;
+        minInt = minInt <= 0 ? 1 : minInt > kMaxIntFracSig ? 1 : minInt;
+        maxInt = maxInt < 0 ? -1 : maxInt < minInt ? minInt : maxInt > kMaxIntFracSig ? -1 : maxInt;
+    }
+    Precision precision;
+    if (!properties.currencyUsage.isNull()) {
+        precision = Precision::constructCurrency(currencyUsage).withCurrency(currency);
+    } else if (roundingIncrement != 0.0) {
+        precision = Precision::constructIncrement(roundingIncrement, minFrac);
+    } else if (explicitMinMaxSig) {
+        minSig = minSig < 1 ? 1 : minSig > kMaxIntFracSig ? kMaxIntFracSig : minSig;
+        maxSig = maxSig < 0 ? kMaxIntFracSig : maxSig < minSig ? minSig : maxSig > kMaxIntFracSig
+                                                                          ? kMaxIntFracSig : maxSig;
+        precision = Precision::constructSignificant(minSig, maxSig);
+    } else if (explicitMinMaxFrac) {
+        precision = Precision::constructFraction(minFrac, maxFrac);
+    } else if (useCurrency) {
+        precision = Precision::constructCurrency(currencyUsage);
+    }
+    if (!precision.isBogus()) {
+        precision = precision.withMode(roundingMode);
+        macros.precision = precision;
+    }
+
+    ///////////////////
+    // INTEGER WIDTH //
+    ///////////////////
+
+    macros.integerWidth = IntegerWidth(
+            static_cast<digits_t>(minInt),
+            static_cast<digits_t>(maxInt),
+            properties.formatFailIfMoreThanMaxDigits);
+
+    ///////////////////////
+    // GROUPING STRATEGY //
+    ///////////////////////
+
+    macros.grouper = Grouper::forProperties(properties);
+
+    /////////////
+    // PADDING //
+    /////////////
+
+    if (properties.formatWidth != -1) {
+        macros.padder = Padder::forProperties(properties);
+    }
+
+    ///////////////////////////////
+    // DECIMAL MARK ALWAYS SHOWN //
+    ///////////////////////////////
+
+    macros.decimal = properties.decimalSeparatorAlwaysShown ? UNUM_DECIMAL_SEPARATOR_ALWAYS
+                                                            : UNUM_DECIMAL_SEPARATOR_AUTO;
+
+    ///////////////////////
+    // SIGN ALWAYS SHOWN //
+    ///////////////////////
+
+    macros.sign = properties.signAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO;
+
+    /////////////////////////
+    // SCIENTIFIC NOTATION //
+    /////////////////////////
+
+    if (properties.minimumExponentDigits != -1) {
+        // Scientific notation is required.
+        // This whole section feels like a hack, but it is needed for regression tests.
+        // The mapping from property bag to scientific notation is nontrivial due to LDML rules.
+        if (maxInt > 8) {
+            // But #13110: The maximum of 8 digits has unknown origins and is not in the spec.
+            // If maxInt is greater than 8, it is set to minInt, even if minInt is greater than 8.
+            maxInt = minInt;
+            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
+        } else if (maxInt > minInt && minInt > 1) {
+            // Bug #13289: if maxInt > minInt > 1, then minInt should be 1.
+            minInt = 1;
+            macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
+        }
+        int engineering = maxInt < 0 ? -1 : maxInt;
+        macros.notation = ScientificNotation(
+                // Engineering interval:
+                static_cast<int8_t>(engineering),
+                // Enforce minimum integer digits (for patterns like "000.00E0"):
+                (engineering == minInt),
+                // Minimum exponent digits:
+                static_cast<digits_t>(properties.minimumExponentDigits),
+                // Exponent sign always shown:
+                properties.exponentSignAlwaysShown ? UNUM_SIGN_ALWAYS : UNUM_SIGN_AUTO);
+        // Scientific notation also involves overriding the rounding mode.
+        // TODO: Overriding here is a bit of a hack. Should this logic go earlier?
+        if (macros.precision.fType == Precision::PrecisionType::RND_FRACTION) {
+            // For the purposes of rounding, get the original min/max int/frac, since the local
+            // variables
+            // have been manipulated for display purposes.
+            int minInt_ = properties.minimumIntegerDigits;
+            int minFrac_ = properties.minimumFractionDigits;
+            int maxFrac_ = properties.maximumFractionDigits;
+            if (minInt_ == 0 && maxFrac_ == 0) {
+                // Patterns like "#E0" and "##E0", which mean no rounding!
+                macros.precision = Precision::unlimited().withMode(roundingMode);
+            } else if (minInt_ == 0 && minFrac_ == 0) {
+                // Patterns like "#.##E0" (no zeros in the mantissa), which mean round to maxFrac+1
+                macros.precision = Precision::constructSignificant(1, maxFrac_ + 1).withMode(roundingMode);
+            } else {
+                // All other scientific patterns, which mean round to minInt+maxFrac
+                macros.precision = Precision::constructSignificant(
+                        minInt_ + minFrac_, minInt_ + maxFrac_).withMode(roundingMode);
+            }
+        }
+    }
+
+    //////////////////////
+    // COMPACT NOTATION //
+    //////////////////////
+
+    if (!properties.compactStyle.isNull()) {
+        if (properties.compactStyle.getNoError() == UNumberCompactStyle::UNUM_LONG) {
+            macros.notation = Notation::compactLong();
+        } else {
+            macros.notation = Notation::compactShort();
+        }
+        // Do not forward the affix provider.
+        macros.affixProvider = nullptr;
+    }
+
+    /////////////////
+    // MULTIPLIERS //
+    /////////////////
+
+    macros.scale = scaleFromProperties(properties);
+
+    //////////////////////
+    // PROPERTY EXPORTS //
+    //////////////////////
+
+    if (exportedProperties != nullptr) {
+
+        exportedProperties->currency = currency;
+        exportedProperties->roundingMode = roundingMode;
+        exportedProperties->minimumIntegerDigits = minInt;
+        exportedProperties->maximumIntegerDigits = maxInt == -1 ? INT32_MAX : maxInt;
+
+        Precision rounding_;
+        if (precision.fType == Precision::PrecisionType::RND_CURRENCY) {
+            rounding_ = precision.withCurrency(currency, status);
+        } else {
+            rounding_ = precision;
+        }
+        int minFrac_ = minFrac;
+        int maxFrac_ = maxFrac;
+        int minSig_ = minSig;
+        int maxSig_ = maxSig;
+        double increment_ = 0.0;
+        if (rounding_.fType == Precision::PrecisionType::RND_FRACTION) {
+            minFrac_ = rounding_.fUnion.fracSig.fMinFrac;
+            maxFrac_ = rounding_.fUnion.fracSig.fMaxFrac;
+        } else if (rounding_.fType == Precision::PrecisionType::RND_INCREMENT) {
+            increment_ = rounding_.fUnion.increment.fIncrement;
+            minFrac_ = rounding_.fUnion.increment.fMinFrac;
+            maxFrac_ = rounding_.fUnion.increment.fMinFrac;
+        } else if (rounding_.fType == Precision::PrecisionType::RND_SIGNIFICANT) {
+            minSig_ = rounding_.fUnion.fracSig.fMinSig;
+            maxSig_ = rounding_.fUnion.fracSig.fMaxSig;
+        }
+
+        exportedProperties->minimumFractionDigits = minFrac_;
+        exportedProperties->maximumFractionDigits = maxFrac_;
+        exportedProperties->minimumSignificantDigits = minSig_;
+        exportedProperties->maximumSignificantDigits = maxSig_;
+        exportedProperties->roundingIncrement = increment_;
+    }
+
+    return macros;
+}
+
+
+void PropertiesAffixPatternProvider::setTo(const DecimalFormatProperties& properties, UErrorCode&) {
+    fBogus = false;
+
+    // There are two ways to set affixes in DecimalFormat: via the pattern string (applyPattern), and via the
+    // explicit setters (setPositivePrefix and friends).  The way to resolve the settings is as follows:
+    //
+    // 1) If the explicit setting is present for the field, use it.
+    // 2) Otherwise, follows UTS 35 rules based on the pattern string.
+    //
+    // Importantly, the explicit setters affect only the one field they override.  If you set the positive
+    // prefix, that should not affect the negative prefix.  Since it is impossible for the user of this class
+    // to know whether the origin for a string was the override or the pattern, we have to say that we always
+    // have a negative subpattern and perform all resolution logic here.
+
+    // Convenience: Extract the properties into local variables.
+    // Variables are named with three chars: [p/n][p/s][o/p]
+    // [p/n] => p for positive, n for negative
+    // [p/s] => p for prefix, s for suffix
+    // [o/p] => o for escaped custom override string, p for pattern string
+    UnicodeString ppo = AffixUtils::escape(properties.positivePrefix);
+    UnicodeString pso = AffixUtils::escape(properties.positiveSuffix);
+    UnicodeString npo = AffixUtils::escape(properties.negativePrefix);
+    UnicodeString nso = AffixUtils::escape(properties.negativeSuffix);
+    const UnicodeString& ppp = properties.positivePrefixPattern;
+    const UnicodeString& psp = properties.positiveSuffixPattern;
+    const UnicodeString& npp = properties.negativePrefixPattern;
+    const UnicodeString& nsp = properties.negativeSuffixPattern;
+
+    if (!properties.positivePrefix.isBogus()) {
+        posPrefix = ppo;
+    } else if (!ppp.isBogus()) {
+        posPrefix = ppp;
+    } else {
+        // UTS 35: Default positive prefix is empty string.
+        posPrefix = u"";
+    }
+
+    if (!properties.positiveSuffix.isBogus()) {
+        posSuffix = pso;
+    } else if (!psp.isBogus()) {
+        posSuffix = psp;
+    } else {
+        // UTS 35: Default positive suffix is empty string.
+        posSuffix = u"";
+    }
+
+    if (!properties.negativePrefix.isBogus()) {
+        negPrefix = npo;
+    } else if (!npp.isBogus()) {
+        negPrefix = npp;
+    } else {
+        // UTS 35: Default negative prefix is "-" with positive prefix.
+        // Important: We prepend the "-" to the pattern, not the override!
+        negPrefix = ppp.isBogus() ? u"-" : u"-" + ppp;
+    }
+
+    if (!properties.negativeSuffix.isBogus()) {
+        negSuffix = nso;
+    } else if (!nsp.isBogus()) {
+        negSuffix = nsp;
+    } else {
+        // UTS 35: Default negative prefix is the positive prefix.
+        negSuffix = psp.isBogus() ? u"" : psp;
+    }
+}
+
+char16_t PropertiesAffixPatternProvider::charAt(int flags, int i) const {
+    return getStringInternal(flags).charAt(i);
+}
+
+int PropertiesAffixPatternProvider::length(int flags) const {
+    return getStringInternal(flags).length();
+}
+
+UnicodeString PropertiesAffixPatternProvider::getString(int32_t flags) const {
+    return getStringInternal(flags);
+}
+
+const UnicodeString& PropertiesAffixPatternProvider::getStringInternal(int32_t flags) const {
+    bool prefix = (flags & AFFIX_PREFIX) != 0;
+    bool negative = (flags & AFFIX_NEGATIVE_SUBPATTERN) != 0;
+    if (prefix && negative) {
+        return negPrefix;
+    } else if (prefix) {
+        return posPrefix;
+    } else if (negative) {
+        return negSuffix;
+    } else {
+        return posSuffix;
+    }
+}
+
+bool PropertiesAffixPatternProvider::positiveHasPlusSign() const {
+    // TODO: Change the internal APIs to propagate out the error?
+    ErrorCode localStatus;
+    return AffixUtils::containsType(posPrefix, TYPE_PLUS_SIGN, localStatus) ||
+           AffixUtils::containsType(posSuffix, TYPE_PLUS_SIGN, localStatus);
+}
+
+bool PropertiesAffixPatternProvider::hasNegativeSubpattern() const {
+    // See comments in the constructor for more information on why this is always true.
+    return true;
+}
+
+bool PropertiesAffixPatternProvider::negativeHasMinusSign() const {
+    ErrorCode localStatus;
+    return AffixUtils::containsType(negPrefix, TYPE_MINUS_SIGN, localStatus) ||
+           AffixUtils::containsType(negSuffix, TYPE_MINUS_SIGN, localStatus);
+}
+
+bool PropertiesAffixPatternProvider::hasCurrencySign() const {
+    ErrorCode localStatus;
+    return AffixUtils::hasCurrencySymbols(posPrefix, localStatus) ||
+           AffixUtils::hasCurrencySymbols(posSuffix, localStatus) ||
+           AffixUtils::hasCurrencySymbols(negPrefix, localStatus) ||
+           AffixUtils::hasCurrencySymbols(negSuffix, localStatus);
+}
+
+bool PropertiesAffixPatternProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
+    return AffixUtils::containsType(posPrefix, type, status) ||
+           AffixUtils::containsType(posSuffix, type, status) ||
+           AffixUtils::containsType(negPrefix, type, status) ||
+           AffixUtils::containsType(negSuffix, type, status);
+}
+
+bool PropertiesAffixPatternProvider::hasBody() const {
+    return true;
+}
+
+
+void CurrencyPluralInfoAffixProvider::setTo(const CurrencyPluralInfo& cpi,
+                                            const DecimalFormatProperties& properties,
+                                            UErrorCode& status) {
+    // We need to use a PropertiesAffixPatternProvider, not the simpler version ParsedPatternInfo,
+    // because user-specified affix overrides still need to work.
+    fBogus = false;
+    DecimalFormatProperties pluralProperties(properties);
+    for (int32_t plural = 0; plural < StandardPlural::COUNT; plural++) {
+        const char* keyword = StandardPlural::getKeyword(static_cast<StandardPlural::Form>(plural));
+        UnicodeString patternString;
+        patternString = cpi.getCurrencyPluralPattern(keyword, patternString);
+        PatternParser::parseToExistingProperties(
+                patternString,
+                pluralProperties,
+                IGNORE_ROUNDING_NEVER,
+                status);
+        affixesByPlural[plural].setTo(pluralProperties, status);
+    }
+}
+
+char16_t CurrencyPluralInfoAffixProvider::charAt(int32_t flags, int32_t i) const {
+    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
+    return affixesByPlural[pluralOrdinal].charAt(flags, i);
+}
+
+int32_t CurrencyPluralInfoAffixProvider::length(int32_t flags) const {
+    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
+    return affixesByPlural[pluralOrdinal].length(flags);
+}
+
+UnicodeString CurrencyPluralInfoAffixProvider::getString(int32_t flags) const {
+    int32_t pluralOrdinal = (flags & AFFIX_PLURAL_MASK);
+    return affixesByPlural[pluralOrdinal].getString(flags);
+}
+
+bool CurrencyPluralInfoAffixProvider::positiveHasPlusSign() const {
+    return affixesByPlural[StandardPlural::OTHER].positiveHasPlusSign();
+}
+
+bool CurrencyPluralInfoAffixProvider::hasNegativeSubpattern() const {
+    return affixesByPlural[StandardPlural::OTHER].hasNegativeSubpattern();
+}
+
+bool CurrencyPluralInfoAffixProvider::negativeHasMinusSign() const {
+    return affixesByPlural[StandardPlural::OTHER].negativeHasMinusSign();
+}
+
+bool CurrencyPluralInfoAffixProvider::hasCurrencySign() const {
+    return affixesByPlural[StandardPlural::OTHER].hasCurrencySign();
+}
+
+bool CurrencyPluralInfoAffixProvider::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
+    return affixesByPlural[StandardPlural::OTHER].containsSymbolType(type, status);
+}
+
+bool CurrencyPluralInfoAffixProvider::hasBody() const {
+    return affixesByPlural[StandardPlural::OTHER].hasBody();
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_mapper.h b/deps/icu-small/source/i18n/number_mapper.h
new file mode 100644
index 00000000000000..82c5711c8d0ce7
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_mapper.h
@@ -0,0 +1,206 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMBER_MAPPER_H__
+#define __NUMBER_MAPPER_H__
+
+#include <atomic>
+#include "number_types.h"
+#include "unicode/currpinf.h"
+#include "standardplural.h"
+#include "number_patternstring.h"
+#include "number_currencysymbols.h"
+#include "numparse_impl.h"
+
+U_NAMESPACE_BEGIN
+namespace number {
+namespace impl {
+
+
+class PropertiesAffixPatternProvider : public AffixPatternProvider, public UMemory {
+  public:
+    bool isBogus() const {
+        return fBogus;
+    }
+
+    void setToBogus() {
+        fBogus = true;
+    }
+
+    void setTo(const DecimalFormatProperties& properties, UErrorCode& status);
+
+    PropertiesAffixPatternProvider() = default; // puts instance in valid but undefined state
+
+    PropertiesAffixPatternProvider(const DecimalFormatProperties& properties, UErrorCode& status) {
+        setTo(properties, status);
+    }
+
+    // AffixPatternProvider Methods:
+
+    char16_t charAt(int32_t flags, int32_t i) const U_OVERRIDE;
+
+    int32_t length(int32_t flags) const U_OVERRIDE;
+
+    UnicodeString getString(int32_t flags) const U_OVERRIDE;
+
+    bool hasCurrencySign() const U_OVERRIDE;
+
+    bool positiveHasPlusSign() const U_OVERRIDE;
+
+    bool hasNegativeSubpattern() const U_OVERRIDE;
+
+    bool negativeHasMinusSign() const U_OVERRIDE;
+
+    bool containsSymbolType(AffixPatternType, UErrorCode&) const U_OVERRIDE;
+
+    bool hasBody() const U_OVERRIDE;
+
+  private:
+    UnicodeString posPrefix;
+    UnicodeString posSuffix;
+    UnicodeString negPrefix;
+    UnicodeString negSuffix;
+
+    const UnicodeString& getStringInternal(int32_t flags) const;
+
+    bool fBogus{true};
+};
+
+
+class CurrencyPluralInfoAffixProvider : public AffixPatternProvider, public UMemory {
+  public:
+    bool isBogus() const {
+        return fBogus;
+    }
+
+    void setToBogus() {
+        fBogus = true;
+    }
+
+    void setTo(const CurrencyPluralInfo& cpi, const DecimalFormatProperties& properties,
+               UErrorCode& status);
+
+    // AffixPatternProvider Methods:
+
+    char16_t charAt(int32_t flags, int32_t i) const U_OVERRIDE;
+
+    int32_t length(int32_t flags) const U_OVERRIDE;
+
+    UnicodeString getString(int32_t flags) const U_OVERRIDE;
+
+    bool hasCurrencySign() const U_OVERRIDE;
+
+    bool positiveHasPlusSign() const U_OVERRIDE;
+
+    bool hasNegativeSubpattern() const U_OVERRIDE;
+
+    bool negativeHasMinusSign() const U_OVERRIDE;
+
+    bool containsSymbolType(AffixPatternType, UErrorCode&) const U_OVERRIDE;
+
+    bool hasBody() const U_OVERRIDE;
+
+  private:
+    PropertiesAffixPatternProvider affixesByPlural[StandardPlural::COUNT];
+
+    bool fBogus{true};
+};
+
+
+/**
+ * A struct for ownership of a few objects needed for formatting.
+ */
+struct DecimalFormatWarehouse {
+    PropertiesAffixPatternProvider propertiesAPP;
+    CurrencyPluralInfoAffixProvider currencyPluralInfoAPP;
+    CurrencySymbols currencySymbols;
+};
+
+
+/**
+* Internal fields for DecimalFormat.
+* TODO: Make some of these fields by value instead of by LocalPointer?
+*/
+struct DecimalFormatFields : public UMemory {
+    /** The property bag corresponding to user-specified settings and settings from the pattern string. */
+    LocalPointer<DecimalFormatProperties> properties;
+
+    /** The symbols for the current locale. */
+    LocalPointer<const DecimalFormatSymbols> symbols;
+
+    /**
+    * The pre-computed formatter object. Setters cause this to be re-computed atomically. The {@link
+    * #format} method uses the formatter directly without needing to synchronize.
+    */
+    LocalPointer<const LocalizedNumberFormatter> formatter;
+
+    /** The lazy-computed parser for .parse() */
+    std::atomic<::icu::numparse::impl::NumberParserImpl*> atomicParser = {};
+
+    /** The lazy-computed parser for .parseCurrency() */
+    std::atomic<::icu::numparse::impl::NumberParserImpl*> atomicCurrencyParser = {};
+
+    /** Small object ownership warehouse for the formatter and parser */
+    DecimalFormatWarehouse warehouse;
+
+    /** The effective properties as exported from the formatter object. Used by some getters. */
+    LocalPointer<DecimalFormatProperties> exportedProperties;
+
+    // Data for fastpath
+    bool canUseFastFormat = false;
+    struct FastFormatData {
+        char16_t cpZero;
+        char16_t cpGroupingSeparator;
+        char16_t cpMinusSign;
+        int8_t minInt;
+        int8_t maxInt;
+    } fastData;
+};
+
+
+/**
+ * Utilities for converting between a DecimalFormatProperties and a MacroProps.
+ */
+class NumberPropertyMapper {
+  public:
+    /** Convenience method to create a NumberFormatter directly from Properties. */
+    static UnlocalizedNumberFormatter create(const DecimalFormatProperties& properties,
+                                             const DecimalFormatSymbols& symbols,
+                                             DecimalFormatWarehouse& warehouse, UErrorCode& status);
+
+    /** Convenience method to create a NumberFormatter directly from Properties. */
+    static UnlocalizedNumberFormatter create(const DecimalFormatProperties& properties,
+                                             const DecimalFormatSymbols& symbols,
+                                             DecimalFormatWarehouse& warehouse,
+                                             DecimalFormatProperties& exportedProperties,
+                                             UErrorCode& status);
+
+    /**
+     * Creates a new {@link MacroProps} object based on the content of a {@link DecimalFormatProperties}
+     * object. In other words, maps Properties to MacroProps. This function is used by the
+     * JDK-compatibility API to call into the ICU 60 fluent number formatting pipeline.
+     *
+     * @param properties
+     *            The property bag to be mapped.
+     * @param symbols
+     *            The symbols associated with the property bag.
+     * @param exportedProperties
+     *            A property bag in which to store validated properties. Used by some DecimalFormat
+     *            getters.
+     * @return A new MacroProps containing all of the information in the Properties.
+     */
+    static MacroProps oldToNew(const DecimalFormatProperties& properties,
+                               const DecimalFormatSymbols& symbols, DecimalFormatWarehouse& warehouse,
+                               DecimalFormatProperties* exportedProperties, UErrorCode& status);
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMBER_MAPPER_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_microprops.h b/deps/icu-small/source/i18n/number_microprops.h
new file mode 100644
index 00000000000000..daa887bb0dd861
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_microprops.h
@@ -0,0 +1,82 @@
+// © 2017 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMBER_MICROPROPS_H__
+#define __NUMBER_MICROPROPS_H__
+
+// TODO: minimize includes
+#include "unicode/numberformatter.h"
+#include "number_types.h"
+#include "number_decimalquantity.h"
+#include "number_scientific.h"
+#include "number_patternstring.h"
+#include "number_modifiers.h"
+#include "number_multiplier.h"
+#include "number_roundingutils.h"
+#include "decNumber.h"
+#include "charstr.h"
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+struct MicroProps : public MicroPropsGenerator {
+
+    // NOTE: All of these fields are properly initialized in NumberFormatterImpl.
+    RoundingImpl rounder;
+    Grouper grouping;
+    Padder padding;
+    IntegerWidth integerWidth;
+    UNumberSignDisplay sign;
+    UNumberDecimalSeparatorDisplay decimal;
+    bool useCurrency;
+
+    // Note: This struct has no direct ownership of the following pointers.
+    const DecimalFormatSymbols* symbols;
+    const Modifier* modOuter;
+    const Modifier* modMiddle;
+    const Modifier* modInner;
+
+    // The following "helper" fields may optionally be used during the MicroPropsGenerator.
+    // They live here to retain memory.
+    struct {
+        ScientificModifier scientificModifier;
+        EmptyModifier emptyWeakModifier{false};
+        EmptyModifier emptyStrongModifier{true};
+        MultiplierFormatHandler multiplier;
+    } helpers;
+
+
+    MicroProps() = default;
+
+    MicroProps(const MicroProps& other) = default;
+
+    MicroProps& operator=(const MicroProps& other) = default;
+
+    void processQuantity(DecimalQuantity&, MicroProps& micros, UErrorCode& status) const U_OVERRIDE {
+        (void) status;
+        if (this == &micros) {
+            // Unsafe path: no need to perform a copy.
+            U_ASSERT(!exhausted);
+            micros.exhausted = true;
+            U_ASSERT(exhausted);
+        } else {
+            // Safe path: copy self into the output micros.
+            micros = *this;
+        }
+    }
+
+  private:
+    // Internal fields:
+    bool exhausted = false;
+};
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif // __NUMBER_MICROPROPS_H__
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_modifiers.cpp b/deps/icu-small/source/i18n/number_modifiers.cpp
index 872b97010d74b7..4385499b54f603 100644
--- a/deps/icu-small/source/i18n/number_modifiers.cpp
+++ b/deps/icu-small/source/i18n/number_modifiers.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "umutex.h"
 #include "ucln_cmn.h"
@@ -32,6 +32,7 @@ UBool U_CALLCONV cleanupDefaultCurrencySpacing() {
     UNISET_DIGIT = nullptr;
     delete UNISET_NOTS;
     UNISET_NOTS = nullptr;
+    gDefaultCurrencySpacingInitOnce.reset();
     return TRUE;
 }
 
@@ -50,6 +51,9 @@ void U_CALLCONV initDefaultCurrencySpacing(UErrorCode &status) {
 }  // namespace
 
 
+Modifier::~Modifier() = default;
+
+
 int32_t ConstantAffixModifier::apply(NumberStringBuilder &output, int leftIndex, int rightIndex,
                                      UErrorCode &status) const {
     // Insert the suffix first since inserting the prefix will change the rightIndex
diff --git a/deps/icu-small/source/i18n/number_modifiers.h b/deps/icu-small/source/i18n/number_modifiers.h
index 4762a6f6d37a2d..a553100cd92a9b 100644
--- a/deps/icu-small/source/i18n/number_modifiers.h
+++ b/deps/icu-small/source/i18n/number_modifiers.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_MODIFIERS_H__
 #define __NUMBER_MODIFIERS_H__
 
diff --git a/deps/icu-small/source/i18n/number_multiplier.cpp b/deps/icu-small/source/i18n/number_multiplier.cpp
new file mode 100644
index 00000000000000..a27142c9bd689b
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_multiplier.cpp
@@ -0,0 +1,156 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "number_decnum.h"
+#include "number_types.h"
+#include "number_multiplier.h"
+#include "numparse_validators.h"
+#include "number_utils.h"
+#include "decNumber.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using namespace icu::numparse::impl;
+
+
+Scale::Scale(int32_t magnitude, DecNum* arbitraryToAdopt)
+        : fMagnitude(magnitude), fArbitrary(arbitraryToAdopt), fError(U_ZERO_ERROR) {
+    if (fArbitrary != nullptr) {
+        // Attempt to convert the DecNum to a magnitude multiplier.
+        fArbitrary->normalize();
+        if (fArbitrary->getRawDecNumber()->digits == 1 && fArbitrary->getRawDecNumber()->lsu[0] == 1 &&
+            !fArbitrary->isNegative()) {
+            // Success!
+            fMagnitude += fArbitrary->getRawDecNumber()->exponent;
+            delete fArbitrary;
+            fArbitrary = nullptr;
+        }
+    }
+}
+
+Scale::Scale(const Scale& other)
+        : fMagnitude(other.fMagnitude), fArbitrary(nullptr), fError(other.fError) {
+    if (other.fArbitrary != nullptr) {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        fArbitrary = new DecNum(*other.fArbitrary, localStatus);
+    }
+}
+
+Scale& Scale::operator=(const Scale& other) {
+    fMagnitude = other.fMagnitude;
+    if (other.fArbitrary != nullptr) {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        fArbitrary = new DecNum(*other.fArbitrary, localStatus);
+    } else {
+        fArbitrary = nullptr;
+    }
+    fError = other.fError;
+    return *this;
+}
+
+Scale::Scale(Scale&& src) U_NOEXCEPT
+        : fMagnitude(src.fMagnitude), fArbitrary(src.fArbitrary), fError(src.fError) {
+    // Take ownership away from src if necessary
+    src.fArbitrary = nullptr;
+}
+
+Scale& Scale::operator=(Scale&& src) U_NOEXCEPT {
+    fMagnitude = src.fMagnitude;
+    fArbitrary = src.fArbitrary;
+    fError = src.fError;
+    // Take ownership away from src if necessary
+    src.fArbitrary = nullptr;
+    return *this;
+}
+
+Scale::~Scale() {
+    delete fArbitrary;
+}
+
+
+Scale Scale::none() {
+    return {0, nullptr};
+}
+
+Scale Scale::powerOfTen(int32_t power) {
+    return {power, nullptr};
+}
+
+Scale Scale::byDecimal(StringPiece multiplicand) {
+    UErrorCode localError = U_ZERO_ERROR;
+    LocalPointer<DecNum> decnum(new DecNum(), localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    decnum->setTo(multiplicand, localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    return {0, decnum.orphan()};
+}
+
+Scale Scale::byDouble(double multiplicand) {
+    UErrorCode localError = U_ZERO_ERROR;
+    LocalPointer<DecNum> decnum(new DecNum(), localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    decnum->setTo(multiplicand, localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    return {0, decnum.orphan()};
+}
+
+Scale Scale::byDoubleAndPowerOfTen(double multiplicand, int32_t power) {
+    UErrorCode localError = U_ZERO_ERROR;
+    LocalPointer<DecNum> decnum(new DecNum(), localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    decnum->setTo(multiplicand, localError);
+    if (U_FAILURE(localError)) {
+        return {localError};
+    }
+    return {power, decnum.orphan()};
+}
+
+void Scale::applyTo(impl::DecimalQuantity& quantity) const {
+    quantity.adjustMagnitude(fMagnitude);
+    if (fArbitrary != nullptr) {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        quantity.multiplyBy(*fArbitrary, localStatus);
+    }
+}
+
+void Scale::applyReciprocalTo(impl::DecimalQuantity& quantity) const {
+    quantity.adjustMagnitude(-fMagnitude);
+    if (fArbitrary != nullptr) {
+        UErrorCode localStatus = U_ZERO_ERROR;
+        quantity.divideBy(*fArbitrary, localStatus);
+    }
+}
+
+
+void
+MultiplierFormatHandler::setAndChain(const Scale& multiplier, const MicroPropsGenerator* parent) {
+    this->multiplier = multiplier;
+    this->parent = parent;
+}
+
+void MultiplierFormatHandler::processQuantity(DecimalQuantity& quantity, MicroProps& micros,
+                                              UErrorCode& status) const {
+    parent->processQuantity(quantity, micros, status);
+    multiplier.applyTo(quantity);
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_multiplier.h b/deps/icu-small/source/i18n/number_multiplier.h
new file mode 100644
index 00000000000000..82c30c78426cdb
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_multiplier.h
@@ -0,0 +1,57 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMBER_MULTIPLIER_H__
+#define __SOURCE_NUMBER_MULTIPLIER_H__
+
+#include "numparse_types.h"
+#include "number_decimfmtprops.h"
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+
+/**
+ * Wraps a {@link Multiplier} for use in the number formatting pipeline.
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API MultiplierFormatHandler : public MicroPropsGenerator, public UMemory {
+  public:
+    MultiplierFormatHandler() = default; // WARNING: Leaves object in an unusable state; call setAndChain()
+
+    void setAndChain(const Scale& multiplier, const MicroPropsGenerator* parent);
+
+    void processQuantity(DecimalQuantity& quantity, MicroProps& micros,
+                         UErrorCode& status) const U_OVERRIDE;
+
+  private:
+    Scale multiplier;
+    const MicroPropsGenerator *parent;
+};
+
+
+/** Gets a Scale from a DecimalFormatProperties. In Java, defined in RoundingUtils.java */
+static inline Scale scaleFromProperties(const DecimalFormatProperties& properties) {
+    int32_t magnitudeMultiplier = properties.magnitudeMultiplier + properties.multiplierScale;
+    int32_t arbitraryMultiplier = properties.multiplier;
+    if (magnitudeMultiplier != 0 && arbitraryMultiplier != 1) {
+        return Scale::byDoubleAndPowerOfTen(arbitraryMultiplier, magnitudeMultiplier);
+    } else if (magnitudeMultiplier != 0) {
+        return Scale::powerOfTen(magnitudeMultiplier);
+    } else if (arbitraryMultiplier != 1) {
+        return Scale::byDouble(arbitraryMultiplier);
+    } else {
+        return Scale::none();
+    }
+}
+
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMBER_MULTIPLIER_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_notation.cpp b/deps/icu-small/source/i18n/number_notation.cpp
index f4ad333354d0c7..b3cabb57a50ea7 100644
--- a/deps/icu-small/source/i18n/number_notation.cpp
+++ b/deps/icu-small/source/i18n/number_notation.cpp
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "unicode/numberformatter.h"
 #include "number_types.h"
@@ -36,6 +36,19 @@ ScientificNotation Notation::engineering() {
     return {NTN_SCIENTIFIC, union_};
 }
 
+ScientificNotation::ScientificNotation(int8_t fEngineeringInterval, bool fRequireMinInt,
+                                       impl::digits_t fMinExponentDigits,
+                                       UNumberSignDisplay fExponentSignDisplay) {
+    ScientificSettings settings;
+    settings.fEngineeringInterval = fEngineeringInterval;
+    settings.fRequireMinInt = fRequireMinInt;
+    settings.fMinExponentDigits = fMinExponentDigits;
+    settings.fExponentSignDisplay = fExponentSignDisplay;
+    NotationUnion union_;
+    union_.scientific = settings;
+    *this = {NTN_SCIENTIFIC, union_};
+}
+
 Notation Notation::compactShort() {
     NotationUnion union_;
     union_.compactStyle = CompactStyle::UNUM_SHORT;
diff --git a/deps/icu-small/source/i18n/number_padding.cpp b/deps/icu-small/source/i18n/number_padding.cpp
index b1db3490cd4489..97e7b6014f9aac 100644
--- a/deps/icu-small/source/i18n/number_padding.cpp
+++ b/deps/icu-small/source/i18n/number_padding.cpp
@@ -3,11 +3,12 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "unicode/numberformatter.h"
 #include "number_types.h"
 #include "number_stringbuilder.h"
+#include "number_decimfmtprops.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -28,6 +29,7 @@ addPaddingHelper(UChar32 paddingCp, int32_t requiredPadding, NumberStringBuilder
 }
 
 Padder::Padder(UChar32 cp, int32_t width, UNumberFormatPadPosition position) : fWidth(width) {
+    // TODO(13034): Consider making this a string instead of code point.
     fUnion.padding.fCp = cp;
     fUnion.padding.fPosition = position;
 }
@@ -47,6 +49,16 @@ Padder Padder::codePoints(UChar32 cp, int32_t targetWidth, UNumberFormatPadPosit
     }
 }
 
+Padder Padder::forProperties(const DecimalFormatProperties& properties) {
+    UChar32 padCp;
+    if (properties.padString.length() > 0) {
+        padCp = properties.padString.char32At(0);
+    } else {
+        padCp = kFallbackPaddingString[0];
+    }
+    return {padCp, properties.formatWidth, properties.padPosition.getOrDefault(UNUM_PAD_BEFORE_PREFIX)};
+}
+
 int32_t Padder::padAndApply(const Modifier &mod1, const Modifier &mod2,
                             NumberStringBuilder &string, int32_t leftIndex, int32_t rightIndex,
                             UErrorCode &status) const {
diff --git a/deps/icu-small/source/i18n/number_patternmodifier.cpp b/deps/icu-small/source/i18n/number_patternmodifier.cpp
index e182104c9116e7..6417e14378bea6 100644
--- a/deps/icu-small/source/i18n/number_patternmodifier.cpp
+++ b/deps/icu-small/source/i18n/number_patternmodifier.cpp
@@ -3,21 +3,27 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "cstring.h"
 #include "number_patternmodifier.h"
 #include "unicode/dcfmtsym.h"
 #include "unicode/ucurr.h"
 #include "unicode/unistr.h"
+#include "number_microprops.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
-MutablePatternModifier::MutablePatternModifier(bool isStrong) : fStrong(isStrong) {}
 
-void MutablePatternModifier::setPatternInfo(const AffixPatternProvider *patternInfo) {
+AffixPatternProvider::~AffixPatternProvider() = default;
+
+
+MutablePatternModifier::MutablePatternModifier(bool isStrong)
+        : fStrong(isStrong) {}
+
+void MutablePatternModifier::setPatternInfo(const AffixPatternProvider* patternInfo) {
     this->patternInfo = patternInfo;
 }
 
@@ -26,14 +32,12 @@ void MutablePatternModifier::setPatternAttributes(UNumberSignDisplay signDisplay
     this->perMilleReplacesPercent = perMille;
 }
 
-void
-MutablePatternModifier::setSymbols(const DecimalFormatSymbols *symbols, const CurrencyUnit &currency,
-                                   const UNumberUnitWidth unitWidth, const PluralRules *rules) {
+void MutablePatternModifier::setSymbols(const DecimalFormatSymbols* symbols,
+                                        const CurrencySymbols* currencySymbols,
+                                        const UNumberUnitWidth unitWidth, const PluralRules* rules) {
     U_ASSERT((rules != nullptr) == needsPlurals());
     this->symbols = symbols;
-    uprv_memcpy(static_cast<char16_t *>(this->currencyCode),
-            currency.getISOCurrency(),
-            sizeof(char16_t) * 4);
+    this->currencySymbols = currencySymbols;
     this->unitWidth = unitWidth;
     this->rules = rules;
 }
@@ -49,12 +53,12 @@ bool MutablePatternModifier::needsPlurals() const {
     // Silently ignore any error codes.
 }
 
-ImmutablePatternModifier *MutablePatternModifier::createImmutable(UErrorCode &status) {
+ImmutablePatternModifier* MutablePatternModifier::createImmutable(UErrorCode& status) {
     return createImmutableAndChain(nullptr, status);
 }
 
-ImmutablePatternModifier *
-MutablePatternModifier::createImmutableAndChain(const MicroPropsGenerator *parent, UErrorCode &status) {
+ImmutablePatternModifier*
+MutablePatternModifier::createImmutableAndChain(const MicroPropsGenerator* parent, UErrorCode& status) {
 
     // TODO: Move StandardPlural VALUES to standardplural.h
     static const StandardPlural::Form STANDARD_PLURAL_VALUES[] = {
@@ -89,11 +93,11 @@ MutablePatternModifier::createImmutableAndChain(const MicroPropsGenerator *paren
     } else {
         // Faster path when plural keyword is not needed.
         setNumberProperties(1, StandardPlural::Form::COUNT);
-        Modifier *positive = createConstantModifier(status);
+        Modifier* positive = createConstantModifier(status);
         setNumberProperties(0, StandardPlural::Form::COUNT);
-        Modifier *zero = createConstantModifier(status);
+        Modifier* zero = createConstantModifier(status);
         setNumberProperties(-1, StandardPlural::Form::COUNT);
-        Modifier *negative = createConstantModifier(status);
+        Modifier* negative = createConstantModifier(status);
         pm->adoptPositiveNegativeModifiers(positive, zero, negative);
         if (U_FAILURE(status)) {
             delete pm;
@@ -103,77 +107,91 @@ MutablePatternModifier::createImmutableAndChain(const MicroPropsGenerator *paren
     }
 }
 
-ConstantMultiFieldModifier *MutablePatternModifier::createConstantModifier(UErrorCode &status) {
+ConstantMultiFieldModifier* MutablePatternModifier::createConstantModifier(UErrorCode& status) {
     NumberStringBuilder a;
     NumberStringBuilder b;
     insertPrefix(a, 0, status);
     insertSuffix(b, 0, status);
     if (patternInfo->hasCurrencySign()) {
-        return new CurrencySpacingEnabledModifier(a, b, !patternInfo->hasBody(), fStrong, *symbols, status);
+        return new CurrencySpacingEnabledModifier(
+                a, b, !patternInfo->hasBody(), fStrong, *symbols, status);
     } else {
         return new ConstantMultiFieldModifier(a, b, !patternInfo->hasBody(), fStrong);
     }
 }
 
-ImmutablePatternModifier::ImmutablePatternModifier(ParameterizedModifier *pm, const PluralRules *rules,
-                                                   const MicroPropsGenerator *parent)
+ImmutablePatternModifier::ImmutablePatternModifier(ParameterizedModifier* pm, const PluralRules* rules,
+                                                   const MicroPropsGenerator* parent)
         : pm(pm), rules(rules), parent(parent) {}
 
-void ImmutablePatternModifier::processQuantity(DecimalQuantity &quantity, MicroProps &micros,
-                                               UErrorCode &status) const {
+void ImmutablePatternModifier::processQuantity(DecimalQuantity& quantity, MicroProps& micros,
+                                               UErrorCode& status) const {
     parent->processQuantity(quantity, micros, status);
     applyToMicros(micros, quantity);
 }
 
-void ImmutablePatternModifier::applyToMicros(MicroProps &micros, DecimalQuantity &quantity) const {
+void ImmutablePatternModifier::applyToMicros(MicroProps& micros, DecimalQuantity& quantity) const {
     if (rules == nullptr) {
         micros.modMiddle = pm->getModifier(quantity.signum());
     } else {
         // TODO: Fix this. Avoid the copy.
         DecimalQuantity copy(quantity);
         copy.roundToInfinity();
-        StandardPlural::Form plural = copy.getStandardPlural(rules);
+        StandardPlural::Form plural = utils::getStandardPlural(rules, copy);
         micros.modMiddle = pm->getModifier(quantity.signum(), plural);
     }
 }
 
+const Modifier* ImmutablePatternModifier::getModifier(int8_t signum, StandardPlural::Form plural) const {
+    if (rules == nullptr) {
+        return pm->getModifier(signum);
+    } else {
+        return pm->getModifier(signum, plural);
+    }
+}
+
+
 /** Used by the unsafe code path. */
-MicroPropsGenerator &MutablePatternModifier::addToChain(const MicroPropsGenerator *parent) {
+MicroPropsGenerator& MutablePatternModifier::addToChain(const MicroPropsGenerator* parent) {
     this->parent = parent;
     return *this;
 }
 
-void MutablePatternModifier::processQuantity(DecimalQuantity &fq, MicroProps &micros,
-                                             UErrorCode &status) const {
+void MutablePatternModifier::processQuantity(DecimalQuantity& fq, MicroProps& micros,
+                                             UErrorCode& status) const {
     parent->processQuantity(fq, micros, status);
     // The unsafe code path performs self-mutation, so we need a const_cast.
     // This method needs to be const because it overrides a const method in the parent class.
-    auto nonConstThis = const_cast<MutablePatternModifier *>(this);
+    auto nonConstThis = const_cast<MutablePatternModifier*>(this);
     if (needsPlurals()) {
         // TODO: Fix this. Avoid the copy.
         DecimalQuantity copy(fq);
-        micros.rounding.apply(copy, status);
-        nonConstThis->setNumberProperties(fq.signum(), copy.getStandardPlural(rules));
+        micros.rounder.apply(copy, status);
+        nonConstThis->setNumberProperties(fq.signum(), utils::getStandardPlural(rules, copy));
     } else {
         nonConstThis->setNumberProperties(fq.signum(), StandardPlural::Form::COUNT);
     }
     micros.modMiddle = this;
 }
 
-int32_t MutablePatternModifier::apply(NumberStringBuilder &output, int32_t leftIndex, int32_t rightIndex,
-                                      UErrorCode &status) const {
+int32_t MutablePatternModifier::apply(NumberStringBuilder& output, int32_t leftIndex, int32_t rightIndex,
+                                      UErrorCode& status) const {
     // The unsafe code path performs self-mutation, so we need a const_cast.
     // This method needs to be const because it overrides a const method in the parent class.
-    auto nonConstThis = const_cast<MutablePatternModifier *>(this);
+    auto nonConstThis = const_cast<MutablePatternModifier*>(this);
     int32_t prefixLen = nonConstThis->insertPrefix(output, leftIndex, status);
     int32_t suffixLen = nonConstThis->insertSuffix(output, rightIndex + prefixLen, status);
     // If the pattern had no decimal stem body (like #,##0.00), overwrite the value.
     int32_t overwriteLen = 0;
     if (!patternInfo->hasBody()) {
         overwriteLen = output.splice(
-            leftIndex + prefixLen, rightIndex + prefixLen,
-            UnicodeString(), 0, 0, UNUM_FIELD_COUNT,
-            status);
+                leftIndex + prefixLen,
+                rightIndex + prefixLen,
+                UnicodeString(),
+                0,
+                0,
+                UNUM_FIELD_COUNT,
+                status);
     }
     CurrencySpacingEnabledModifier::applyCurrencySpacing(
             output,
@@ -186,30 +204,27 @@ int32_t MutablePatternModifier::apply(NumberStringBuilder &output, int32_t leftI
     return prefixLen + overwriteLen + suffixLen;
 }
 
-int32_t MutablePatternModifier::getPrefixLength(UErrorCode &status) const {
+int32_t MutablePatternModifier::getPrefixLength(UErrorCode& status) const {
     // The unsafe code path performs self-mutation, so we need a const_cast.
     // This method needs to be const because it overrides a const method in the parent class.
-    auto nonConstThis = const_cast<MutablePatternModifier *>(this);
+    auto nonConstThis = const_cast<MutablePatternModifier*>(this);
 
     // Enter and exit CharSequence Mode to get the length.
-    nonConstThis->enterCharSequenceMode(true);
-    int result = AffixUtils::unescapedCodePointCount(*this, *this, status);  // prefix length
-    nonConstThis->exitCharSequenceMode();
+    nonConstThis->prepareAffix(true);
+    int result = AffixUtils::unescapedCodePointCount(currentAffix, *this, status);  // prefix length
     return result;
 }
 
-int32_t MutablePatternModifier::getCodePointCount(UErrorCode &status) const {
+int32_t MutablePatternModifier::getCodePointCount(UErrorCode& status) const {
     // The unsafe code path performs self-mutation, so we need a const_cast.
     // This method needs to be const because it overrides a const method in the parent class.
-    auto nonConstThis = const_cast<MutablePatternModifier *>(this);
+    auto nonConstThis = const_cast<MutablePatternModifier*>(this);
 
-    // Enter and exit CharSequence Mode to get the length.
-    nonConstThis->enterCharSequenceMode(true);
-    int result = AffixUtils::unescapedCodePointCount(*this, *this, status);  // prefix length
-    nonConstThis->exitCharSequenceMode();
-    nonConstThis->enterCharSequenceMode(false);
-    result += AffixUtils::unescapedCodePointCount(*this, *this, status);  // suffix length
-    nonConstThis->exitCharSequenceMode();
+    // Render the affixes to get the length
+    nonConstThis->prepareAffix(true);
+    int result = AffixUtils::unescapedCodePointCount(currentAffix, *this, status);  // prefix length
+    nonConstThis->prepareAffix(false);
+    result += AffixUtils::unescapedCodePointCount(currentAffix, *this, status);  // suffix length
     return result;
 }
 
@@ -217,21 +232,26 @@ bool MutablePatternModifier::isStrong() const {
     return fStrong;
 }
 
-int32_t MutablePatternModifier::insertPrefix(NumberStringBuilder &sb, int position, UErrorCode &status) {
-    enterCharSequenceMode(true);
-    int length = AffixUtils::unescape(*this, sb, position, *this, status);
-    exitCharSequenceMode();
+int32_t MutablePatternModifier::insertPrefix(NumberStringBuilder& sb, int position, UErrorCode& status) {
+    prepareAffix(true);
+    int length = AffixUtils::unescape(currentAffix, sb, position, *this, status);
     return length;
 }
 
-int32_t MutablePatternModifier::insertSuffix(NumberStringBuilder &sb, int position, UErrorCode &status) {
-    enterCharSequenceMode(false);
-    int length = AffixUtils::unescape(*this, sb, position, *this, status);
-    exitCharSequenceMode();
+int32_t MutablePatternModifier::insertSuffix(NumberStringBuilder& sb, int position, UErrorCode& status) {
+    prepareAffix(false);
+    int length = AffixUtils::unescape(currentAffix, sb, position, *this, status);
     return length;
 }
 
+/** This method contains the heart of the logic for rendering LDML affix strings. */
+void MutablePatternModifier::prepareAffix(bool isPrefix) {
+    PatternStringUtils::patternInfoToStringBuilder(
+            *patternInfo, isPrefix, signum, signDisplay, plural, perMilleReplacesPercent, currentAffix);
+}
+
 UnicodeString MutablePatternModifier::getSymbol(AffixPatternType type) const {
+    UErrorCode localStatus = U_ZERO_ERROR;
     switch (type) {
         case AffixPatternType::TYPE_MINUS_SIGN:
             return symbols->getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kMinusSignSymbol);
@@ -244,45 +264,23 @@ UnicodeString MutablePatternModifier::getSymbol(AffixPatternType type) const {
         case AffixPatternType::TYPE_CURRENCY_SINGLE: {
             // UnitWidth ISO and HIDDEN overrides the singular currency symbol.
             if (unitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_ISO_CODE) {
-                return UnicodeString(currencyCode, 3);
+                return currencySymbols->getIntlCurrencySymbol(localStatus);
             } else if (unitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_HIDDEN) {
                 return UnicodeString();
+            } else if (unitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW) {
+                return currencySymbols->getNarrowCurrencySymbol(localStatus);
             } else {
-                UCurrNameStyle selector = (unitWidth == UNumberUnitWidth::UNUM_UNIT_WIDTH_NARROW)
-                        ? UCurrNameStyle::UCURR_NARROW_SYMBOL_NAME
-                        : UCurrNameStyle::UCURR_SYMBOL_NAME;
-                UErrorCode status = U_ZERO_ERROR;
-                UBool isChoiceFormat = FALSE;
-                int32_t symbolLen = 0;
-                const char16_t *symbol = ucurr_getName(
-                        currencyCode,
-                        symbols->getLocale().getName(),
-                        selector,
-                        &isChoiceFormat,
-                        &symbolLen,
-                        &status);
-                return UnicodeString(symbol, symbolLen);
+                return currencySymbols->getCurrencySymbol(localStatus);
             }
         }
         case AffixPatternType::TYPE_CURRENCY_DOUBLE:
-            return UnicodeString(currencyCode, 3);
-        case AffixPatternType::TYPE_CURRENCY_TRIPLE: {
+            return currencySymbols->getIntlCurrencySymbol(localStatus);
+        case AffixPatternType::TYPE_CURRENCY_TRIPLE:
             // NOTE: This is the code path only for patterns containing "¤¤¤".
             // Plural currencies set via the API are formatted in LongNameHandler.
             // This code path is used by DecimalFormat via CurrencyPluralInfo.
             U_ASSERT(plural != StandardPlural::Form::COUNT);
-            UErrorCode status = U_ZERO_ERROR;
-            UBool isChoiceFormat = FALSE;
-            int32_t symbolLen = 0;
-            const char16_t *symbol = ucurr_getPluralName(
-                    currencyCode,
-                    symbols->getLocale().getName(),
-                    &isChoiceFormat,
-                    StandardPlural::getKeyword(plural),
-                    &symbolLen,
-                    &status);
-            return UnicodeString(symbol, symbolLen);
-        }
+            return currencySymbols->getPluralName(plural, localStatus);
         case AffixPatternType::TYPE_CURRENCY_QUAD:
             return UnicodeString(u"\uFFFD");
         case AffixPatternType::TYPE_CURRENCY_QUINT:
@@ -293,79 +291,6 @@ UnicodeString MutablePatternModifier::getSymbol(AffixPatternType type) const {
     }
 }
 
-/** This method contains the heart of the logic for rendering LDML affix strings. */
-void MutablePatternModifier::enterCharSequenceMode(bool isPrefix) {
-    U_ASSERT(!inCharSequenceMode);
-    inCharSequenceMode = true;
-
-    // Should the output render '+' where '-' would normally appear in the pattern?
-    plusReplacesMinusSign = signum != -1
-            && (signDisplay == UNUM_SIGN_ALWAYS
-                    || signDisplay == UNUM_SIGN_ACCOUNTING_ALWAYS
-                    || (signum == 1
-                            && (signDisplay == UNUM_SIGN_EXCEPT_ZERO
-                                    || signDisplay == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO)))
-            && patternInfo->positiveHasPlusSign() == false;
-
-    // Should we use the affix from the negative subpattern? (If not, we will use the positive subpattern.)
-    bool useNegativeAffixPattern = patternInfo->hasNegativeSubpattern() && (
-            signum == -1 || (patternInfo->negativeHasMinusSign() && plusReplacesMinusSign));
-
-    // Resolve the flags for the affix pattern.
-    fFlags = 0;
-    if (useNegativeAffixPattern) {
-        fFlags |= AffixPatternProvider::AFFIX_NEGATIVE_SUBPATTERN;
-    }
-    if (isPrefix) {
-        fFlags |= AffixPatternProvider::AFFIX_PREFIX;
-    }
-    if (plural != StandardPlural::Form::COUNT) {
-        U_ASSERT(plural == (AffixPatternProvider::AFFIX_PLURAL_MASK & plural));
-        fFlags |= plural;
-    }
-
-    // Should we prepend a sign to the pattern?
-    if (!isPrefix || useNegativeAffixPattern) {
-        prependSign = false;
-    } else if (signum == -1) {
-        prependSign = signDisplay != UNUM_SIGN_NEVER;
-    } else {
-        prependSign = plusReplacesMinusSign;
-    }
-
-    // Finally, compute the length of the affix pattern.
-    fLength = patternInfo->length(fFlags) + (prependSign ? 1 : 0);
-}
-
-void MutablePatternModifier::exitCharSequenceMode() {
-    U_ASSERT(inCharSequenceMode);
-    inCharSequenceMode = false;
-}
-
-int32_t MutablePatternModifier::length() const {
-    U_ASSERT(inCharSequenceMode);
-    return fLength;
-}
-
-char16_t MutablePatternModifier::charAt(int32_t index) const {
-    U_ASSERT(inCharSequenceMode);
-    char16_t candidate;
-    if (prependSign && index == 0) {
-        candidate = u'-';
-    } else if (prependSign) {
-        candidate = patternInfo->charAt(fFlags, index - 1);
-    } else {
-        candidate = patternInfo->charAt(fFlags, index);
-    }
-    if (plusReplacesMinusSign && candidate == u'-') {
-        return u'+';
-    }
-    if (perMilleReplacesPercent && candidate == u'%') {
-        return u'‰';
-    }
-    return candidate;
-}
-
 UnicodeString MutablePatternModifier::toUnicodeString() const {
     // Never called by AffixUtils
     U_ASSERT(false);
diff --git a/deps/icu-small/source/i18n/number_patternmodifier.h b/deps/icu-small/source/i18n/number_patternmodifier.h
index 9c8b95f7764436..f1359bd5747d89 100644
--- a/deps/icu-small/source/i18n/number_patternmodifier.h
+++ b/deps/icu-small/source/i18n/number_patternmodifier.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_PATTERNMODIFIER_H__
 #define __NUMBER_PATTERNMODIFIER_H__
 
@@ -13,6 +13,7 @@
 #include "number_types.h"
 #include "number_modifiers.h"
 #include "number_utils.h"
+#include "number_currencysymbols.h"
 
 U_NAMESPACE_BEGIN
 
@@ -35,20 +36,23 @@ class MutablePatternModifier;
 // Exported as U_I18N_API because it is needed for the unit test PatternModifierTest
 class U_I18N_API ImmutablePatternModifier : public MicroPropsGenerator, public UMemory {
   public:
-	~ImmutablePatternModifier() U_OVERRIDE = default;
+    ~ImmutablePatternModifier() U_OVERRIDE = default;
 
-    void processQuantity(DecimalQuantity &, MicroProps &micros, UErrorCode &status) const U_OVERRIDE;
+    void processQuantity(DecimalQuantity&, MicroProps& micros, UErrorCode& status) const U_OVERRIDE;
+
+    void applyToMicros(MicroProps& micros, DecimalQuantity& quantity) const;
 
-    void applyToMicros(MicroProps &micros, DecimalQuantity &quantity) const;
+    const Modifier* getModifier(int8_t signum, StandardPlural::Form plural) const;
 
   private:
-    ImmutablePatternModifier(ParameterizedModifier *pm, const PluralRules *rules, const MicroPropsGenerator *parent);
+    ImmutablePatternModifier(ParameterizedModifier* pm, const PluralRules* rules,
+                             const MicroPropsGenerator* parent);
 
     const LocalPointer<ParameterizedModifier> pm;
-    const PluralRules *rules;
-    const MicroPropsGenerator *parent;
+    const PluralRules* rules;
+    const MicroPropsGenerator* parent;
 
-	friend class MutablePatternModifier;
+    friend class MutablePatternModifier;
 };
 
 /**
@@ -74,7 +78,6 @@ class U_I18N_API MutablePatternModifier
         : public MicroPropsGenerator,
           public Modifier,
           public SymbolProvider,
-          public CharSequence,
           public UMemory {
   public:
 
@@ -110,17 +113,16 @@ class U_I18N_API MutablePatternModifier
      *
      * @param symbols
      *            The desired instance of DecimalFormatSymbols.
-     * @param currency
-     *            The currency to be used when substituting currency values into the affixes.
+     * @param currencySymbols
+     *            The currency symbols to be used when substituting currency values into the affixes.
      * @param unitWidth
      *            The width used to render currencies.
      * @param rules
      *            Required if the triple currency sign, "¤¤¤", appears in the pattern, which can be determined from the
      *            convenience method {@link #needsPlurals()}.
      */
-    void
-    setSymbols(const DecimalFormatSymbols *symbols, const CurrencyUnit &currency, UNumberUnitWidth unitWidth,
-               const PluralRules *rules);
+    void setSymbols(const DecimalFormatSymbols* symbols, const CurrencySymbols* currencySymbols,
+                    UNumberUnitWidth unitWidth, const PluralRules* rules);
 
     /**
      * Sets attributes of the current number being processed.
@@ -187,13 +189,7 @@ class U_I18N_API MutablePatternModifier
      */
     UnicodeString getSymbol(AffixPatternType type) const U_OVERRIDE;
 
-    int32_t length() const U_OVERRIDE;
-
-    char16_t charAt(int32_t index) const U_OVERRIDE;
-
-    // Use default implementation of codePointAt
-
-    UnicodeString toUnicodeString() const U_OVERRIDE;
+    UnicodeString toUnicodeString() const;
 
   private:
     // Modifier details (initialized in constructor)
@@ -207,7 +203,7 @@ class U_I18N_API MutablePatternModifier
     // Symbol details (initialized in setSymbols)
     const DecimalFormatSymbols *symbols;
     UNumberUnitWidth unitWidth;
-    char16_t currencyCode[4];
+    const CurrencySymbols *currencySymbols;
     const PluralRules *rules;
 
     // Number details (initialized in setNumberProperties)
@@ -217,12 +213,8 @@ class U_I18N_API MutablePatternModifier
     // QuantityChain details (initialized in addToChain)
     const MicroPropsGenerator *parent;
 
-    // Transient CharSequence fields (initialized in enterCharSequenceMode)
-    bool inCharSequenceMode = false;
-    int32_t fFlags;
-    int32_t fLength;
-    bool prependSign;
-    bool plusReplacesMinusSign;
+    // Transient fields for rendering
+    UnicodeString currentAffix;
 
     /**
      * Uses the current properties to create a single {@link ConstantMultiFieldModifier} with currency spacing support
@@ -244,9 +236,7 @@ class U_I18N_API MutablePatternModifier
 
     int32_t insertSuffix(NumberStringBuilder &sb, int position, UErrorCode &status);
 
-    void enterCharSequenceMode(bool isPrefix);
-
-    void exitCharSequenceMode();
+    void prepareAffix(bool isPrefix);
 };
 
 
diff --git a/deps/icu-small/source/i18n/number_patternstring.cpp b/deps/icu-small/source/i18n/number_patternstring.cpp
index 20178824b0e20a..63195eed989e54 100644
--- a/deps/icu-small/source/i18n/number_patternstring.cpp
+++ b/deps/icu-small/source/i18n/number_patternstring.cpp
@@ -3,36 +3,51 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+#define UNISTR_FROM_CHAR_EXPLICIT
 
 #include "uassert.h"
 #include "number_patternstring.h"
 #include "unicode/utf16.h"
 #include "number_utils.h"
+#include "number_roundingutils.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
-void PatternParser::parseToPatternInfo(const UnicodeString& patternString, ParsedPatternInfo& patternInfo, UErrorCode &status) {
+
+void PatternParser::parseToPatternInfo(const UnicodeString& patternString, ParsedPatternInfo& patternInfo,
+                                       UErrorCode& status) {
     patternInfo.consumePattern(patternString, status);
 }
 
 DecimalFormatProperties
 PatternParser::parseToProperties(const UnicodeString& pattern, IgnoreRounding ignoreRounding,
-                                 UErrorCode &status) {
+                                 UErrorCode& status) {
     DecimalFormatProperties properties;
     parseToExistingPropertiesImpl(pattern, properties, ignoreRounding, status);
     return properties;
 }
 
-void PatternParser::parseToExistingProperties(const UnicodeString& pattern, DecimalFormatProperties& properties,
-                                              IgnoreRounding ignoreRounding, UErrorCode &status) {
+DecimalFormatProperties PatternParser::parseToProperties(const UnicodeString& pattern,
+                                                         UErrorCode& status) {
+    return parseToProperties(pattern, IGNORE_ROUNDING_NEVER, status);
+}
+
+void
+PatternParser::parseToExistingProperties(const UnicodeString& pattern, DecimalFormatProperties& properties,
+                                         IgnoreRounding ignoreRounding, UErrorCode& status) {
     parseToExistingPropertiesImpl(pattern, properties, ignoreRounding, status);
 }
 
+
 char16_t ParsedPatternInfo::charAt(int32_t flags, int32_t index) const {
-    const Endpoints &endpoints = getEndpoints(flags);
+    const Endpoints& endpoints = getEndpoints(flags);
     if (index < 0 || index >= endpoints.end - endpoints.start) {
         U_ASSERT(false);
     }
@@ -43,12 +58,12 @@ int32_t ParsedPatternInfo::length(int32_t flags) const {
     return getLengthFromEndpoints(getEndpoints(flags));
 }
 
-int32_t ParsedPatternInfo::getLengthFromEndpoints(const Endpoints &endpoints) {
+int32_t ParsedPatternInfo::getLengthFromEndpoints(const Endpoints& endpoints) {
     return endpoints.end - endpoints.start;
 }
 
 UnicodeString ParsedPatternInfo::getString(int32_t flags) const {
-    const Endpoints &endpoints = getEndpoints(flags);
+    const Endpoints& endpoints = getEndpoints(flags);
     if (endpoints.start == endpoints.end) {
         return UnicodeString();
     }
@@ -56,7 +71,7 @@ UnicodeString ParsedPatternInfo::getString(int32_t flags) const {
     return UnicodeString(pattern, endpoints.start, endpoints.end - endpoints.start);
 }
 
-const Endpoints &ParsedPatternInfo::getEndpoints(int32_t flags) const {
+const Endpoints& ParsedPatternInfo::getEndpoints(int32_t flags) const {
     bool prefix = (flags & AFFIX_PREFIX) != 0;
     bool isNegative = (flags & AFFIX_NEGATIVE_SUBPATTERN) != 0;
     bool padding = (flags & AFFIX_PADDING) != 0;
@@ -91,8 +106,8 @@ bool ParsedPatternInfo::hasCurrencySign() const {
     return positive.hasCurrencySign || (fHasNegativeSubpattern && negative.hasCurrencySign);
 }
 
-bool ParsedPatternInfo::containsSymbolType(AffixPatternType type, UErrorCode &status) const {
-    return AffixUtils::containsType(UnicodeStringCharSequence(pattern), type, status);
+bool ParsedPatternInfo::containsSymbolType(AffixPatternType type, UErrorCode& status) const {
+    return AffixUtils::containsType(pattern, type, status);
 }
 
 bool ParsedPatternInfo::hasBody() const {
@@ -117,10 +132,14 @@ UChar32 ParsedPatternInfo::ParserState::next() {
     return codePoint;
 }
 
-void ParsedPatternInfo::consumePattern(const UnicodeString& patternString, UErrorCode &status) {
+void ParsedPatternInfo::consumePattern(const UnicodeString& patternString, UErrorCode& status) {
     if (U_FAILURE(status)) { return; }
     this->pattern = patternString;
 
+    // This class is not intended for writing twice!
+    // Use move assignment to overwrite instead.
+    U_ASSERT(state.offset == 0);
+
     // pattern := subpattern (';' subpattern)?
     currentSubpattern = &positive;
     consumeSubpattern(status);
@@ -141,7 +160,7 @@ void ParsedPatternInfo::consumePattern(const UnicodeString& patternString, UErro
     }
 }
 
-void ParsedPatternInfo::consumeSubpattern(UErrorCode &status) {
+void ParsedPatternInfo::consumeSubpattern(UErrorCode& status) {
     // subpattern := literals? number exponent? literals?
     consumePadding(PadPosition::UNUM_PAD_BEFORE_PREFIX, status);
     if (U_FAILURE(status)) { return; }
@@ -161,23 +180,24 @@ void ParsedPatternInfo::consumeSubpattern(UErrorCode &status) {
     if (U_FAILURE(status)) { return; }
 }
 
-void ParsedPatternInfo::consumePadding(PadPosition paddingLocation, UErrorCode &status) {
+void ParsedPatternInfo::consumePadding(PadPosition paddingLocation, UErrorCode& status) {
     if (state.peek() != u'*') {
         return;
     }
-    if (!currentSubpattern->paddingLocation.isNull()) {
+    if (currentSubpattern->hasPadding) {
         state.toParseException(u"Cannot have multiple pad specifiers");
         status = U_MULTIPLE_PAD_SPECIFIERS;
         return;
     }
     currentSubpattern->paddingLocation = paddingLocation;
+    currentSubpattern->hasPadding = true;
     state.next(); // consume the '*'
     currentSubpattern->paddingEndpoints.start = state.offset;
     consumeLiteral(status);
     currentSubpattern->paddingEndpoints.end = state.offset;
 }
 
-void ParsedPatternInfo::consumeAffix(Endpoints &endpoints, UErrorCode &status) {
+void ParsedPatternInfo::consumeAffix(Endpoints& endpoints, UErrorCode& status) {
     // literals := { literal }
     endpoints.start = state.offset;
     while (true) {
@@ -233,7 +253,7 @@ void ParsedPatternInfo::consumeAffix(Endpoints &endpoints, UErrorCode &status) {
     endpoints.end = state.offset;
 }
 
-void ParsedPatternInfo::consumeLiteral(UErrorCode &status) {
+void ParsedPatternInfo::consumeLiteral(UErrorCode& status) {
     if (state.peek() == -1) {
         state.toParseException(u"Expected unquoted literal but found EOL");
         status = U_PATTERN_SYNTAX_ERROR;
@@ -256,7 +276,7 @@ void ParsedPatternInfo::consumeLiteral(UErrorCode &status) {
     }
 }
 
-void ParsedPatternInfo::consumeFormat(UErrorCode &status) {
+void ParsedPatternInfo::consumeFormat(UErrorCode& status) {
     consumeIntegerFormat(status);
     if (U_FAILURE(status)) { return; }
     if (state.peek() == u'.') {
@@ -268,9 +288,9 @@ void ParsedPatternInfo::consumeFormat(UErrorCode &status) {
     }
 }
 
-void ParsedPatternInfo::consumeIntegerFormat(UErrorCode &status) {
+void ParsedPatternInfo::consumeIntegerFormat(UErrorCode& status) {
     // Convenience reference:
-    ParsedSubpatternInfo &result = *currentSubpattern;
+    ParsedSubpatternInfo& result = *currentSubpattern;
 
     while (true) {
         switch (state.peek()) {
@@ -359,9 +379,9 @@ void ParsedPatternInfo::consumeIntegerFormat(UErrorCode &status) {
     }
 }
 
-void ParsedPatternInfo::consumeFractionFormat(UErrorCode &status) {
+void ParsedPatternInfo::consumeFractionFormat(UErrorCode& status) {
     // Convenience reference:
-    ParsedSubpatternInfo &result = *currentSubpattern;
+    ParsedSubpatternInfo& result = *currentSubpattern;
 
     int32_t zeroCounter = 0;
     while (true) {
@@ -407,9 +427,9 @@ void ParsedPatternInfo::consumeFractionFormat(UErrorCode &status) {
     }
 }
 
-void ParsedPatternInfo::consumeExponent(UErrorCode &status) {
+void ParsedPatternInfo::consumeExponent(UErrorCode& status) {
     // Convenience reference:
-    ParsedSubpatternInfo &result = *currentSubpattern;
+    ParsedSubpatternInfo& result = *currentSubpattern;
 
     if (state.peek() != u'E') {
         return;
@@ -437,9 +457,9 @@ void ParsedPatternInfo::consumeExponent(UErrorCode &status) {
 /// END RECURSIVE DESCENT PARSER IMPLEMENTATION ///
 ///////////////////////////////////////////////////
 
-void
-PatternParser::parseToExistingPropertiesImpl(const UnicodeString& pattern, DecimalFormatProperties &properties,
-                                             IgnoreRounding ignoreRounding, UErrorCode &status) {
+void PatternParser::parseToExistingPropertiesImpl(const UnicodeString& pattern,
+                                                  DecimalFormatProperties& properties,
+                                                  IgnoreRounding ignoreRounding, UErrorCode& status) {
     if (pattern.length() == 0) {
         // Backwards compatibility requires that we reset to the default values.
         // TODO: Only overwrite the properties that "saveToProperties" normally touches?
@@ -453,13 +473,13 @@ PatternParser::parseToExistingPropertiesImpl(const UnicodeString& pattern, Decim
     patternInfoToProperties(properties, patternInfo, ignoreRounding, status);
 }
 
-void PatternParser::patternInfoToProperties(DecimalFormatProperties &properties,
-                                            ParsedPatternInfo& patternInfo,
-                                            IgnoreRounding _ignoreRounding, UErrorCode &status) {
+void
+PatternParser::patternInfoToProperties(DecimalFormatProperties& properties, ParsedPatternInfo& patternInfo,
+                                       IgnoreRounding _ignoreRounding, UErrorCode& status) {
     // Translate from PatternParseResult to Properties.
     // Note that most data from "negative" is ignored per the specification of DecimalFormat.
 
-    const ParsedSubpatternInfo &positive = patternInfo.positive;
+    const ParsedSubpatternInfo& positive = patternInfo.positive;
 
     bool ignoreRounding;
     if (_ignoreRounding == IGNORE_ROUNDING_NEVER) {
@@ -477,8 +497,10 @@ void PatternParser::patternInfoToProperties(DecimalFormatProperties &properties,
     auto grouping3 = static_cast<int16_t> ((positive.groupingSizes >> 32) & 0xffff);
     if (grouping2 != -1) {
         properties.groupingSize = grouping1;
+        properties.groupingUsed = true;
     } else {
         properties.groupingSize = -1;
+        properties.groupingUsed = false;
     }
     if (grouping3 != -1) {
         properties.secondaryGroupingSize = grouping2;
@@ -508,8 +530,7 @@ void PatternParser::patternInfoToProperties(DecimalFormatProperties &properties,
         properties.maximumFractionDigits = -1;
         properties.roundingIncrement = 0.0;
         properties.minimumSignificantDigits = positive.integerAtSigns;
-        properties.maximumSignificantDigits =
-                positive.integerAtSigns + positive.integerTrailingHashSigns;
+        properties.maximumSignificantDigits = positive.integerAtSigns + positive.integerTrailingHashSigns;
     } else if (!positive.rounding.isZero()) {
         if (!ignoreRounding) {
             properties.minimumFractionDigits = minFrac;
@@ -568,11 +589,11 @@ void PatternParser::patternInfoToProperties(DecimalFormatProperties &properties,
     UnicodeString posSuffix = patternInfo.getString(0);
 
     // Padding settings
-    if (!positive.paddingLocation.isNull()) {
+    if (positive.hasPadding) {
         // The width of the positive prefix and suffix templates are included in the padding
-        int paddingWidth =
-                positive.widthExceptAffixes + AffixUtils::estimateLength(UnicodeStringCharSequence(posPrefix), status) +
-                AffixUtils::estimateLength(UnicodeStringCharSequence(posSuffix), status);
+        int paddingWidth = positive.widthExceptAffixes +
+                           AffixUtils::estimateLength(posPrefix, status) +
+                           AffixUtils::estimateLength(posSuffix, status);
         properties.formatWidth = paddingWidth;
         UnicodeString rawPaddingString = patternInfo.getString(AffixPatternProvider::AFFIX_PADDING);
         if (rawPaddingString.length() == 1) {
@@ -622,8 +643,8 @@ void PatternParser::patternInfoToProperties(DecimalFormatProperties &properties,
 /// End PatternStringParser.java; begin PatternStringUtils.java ///
 ///////////////////////////////////////////////////////////////////
 
-UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatProperties &properties,
-                                                            UErrorCode &status) {
+UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatProperties& properties,
+                                                            UErrorCode& status) {
     UnicodeString sb;
 
     // Convenience references
@@ -656,7 +677,7 @@ UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatP
     if (!ppp.isBogus()) {
         sb.append(ppp);
     }
-    sb.append(AffixUtils::escape(UnicodeStringCharSequence(pp)));
+    sb.append(AffixUtils::escape(pp));
     int afterPrefixPos = sb.length();
 
     // Figure out the grouping sizes.
@@ -695,11 +716,11 @@ UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatP
         }
     } else if (roundingInterval != 0.0) {
         // Rounding Interval.
-        digitsStringScale = minFrac;
+        digitsStringScale = -roundingutils::doubleFractionLength(roundingInterval);
         // TODO: Check for DoS here?
         DecimalQuantity incrementQuantity;
         incrementQuantity.setToDouble(roundingInterval);
-        incrementQuantity.adjustMagnitude(minFrac);
+        incrementQuantity.adjustMagnitude(-digitsStringScale);
         incrementQuantity.roundToMagnitude(0, kDefaultMode, status);
         UnicodeString str = incrementQuantity.toPlainString();
         if (str.charAt(0) == u'-') {
@@ -753,7 +774,7 @@ UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatP
     if (!psp.isBogus()) {
         sb.append(psp);
     }
-    sb.append(AffixUtils::escape(UnicodeStringCharSequence(ps)));
+    sb.append(AffixUtils::escape(ps));
 
     // Resolve Padding
     if (paddingWidth != -1 && !paddingLocation.isNull()) {
@@ -795,22 +816,25 @@ UnicodeString PatternStringUtils::propertiesToPatternString(const DecimalFormatP
         if (!npp.isBogus()) {
             sb.append(npp);
         }
-        sb.append(AffixUtils::escape(UnicodeStringCharSequence(np)));
+        sb.append(AffixUtils::escape(np));
         // Copy the positive digit format into the negative.
         // This is optional; the pattern is the same as if '#' were appended here instead.
-        sb.append(sb, afterPrefixPos, beforeSuffixPos);
+        // NOTE: It is not safe to append the UnicodeString to itself, so we need to copy.
+        // See http://bugs.icu-project.org/trac/ticket/13707
+        UnicodeString copy(sb);
+        sb.append(copy, afterPrefixPos, beforeSuffixPos - afterPrefixPos);
         if (!nsp.isBogus()) {
             sb.append(nsp);
         }
-        sb.append(AffixUtils::escape(UnicodeStringCharSequence(ns)));
+        sb.append(AffixUtils::escape(ns));
     }
 
     return sb;
 }
 
 int PatternStringUtils::escapePaddingString(UnicodeString input, UnicodeString& output, int startIndex,
-                                            UErrorCode &status) {
-    (void)status;
+                                            UErrorCode& status) {
+    (void) status;
     if (input.length() == 0) {
         input.setTo(kFallbackPaddingString, -1);
     }
@@ -840,4 +864,207 @@ int PatternStringUtils::escapePaddingString(UnicodeString input, UnicodeString&
     return output.length() - startLength;
 }
 
+UnicodeString
+PatternStringUtils::convertLocalized(const UnicodeString& input, const DecimalFormatSymbols& symbols,
+                                     bool toLocalized, UErrorCode& status) {
+    // Construct a table of strings to be converted between localized and standard.
+    static constexpr int32_t LEN = 21;
+    UnicodeString table[LEN][2];
+    int standIdx = toLocalized ? 0 : 1;
+    int localIdx = toLocalized ? 1 : 0;
+    table[0][standIdx] = u"%";
+    table[0][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kPercentSymbol);
+    table[1][standIdx] = u"‰";
+    table[1][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kPerMillSymbol);
+    table[2][standIdx] = u".";
+    table[2][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
+    table[3][standIdx] = u",";
+    table[3][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
+    table[4][standIdx] = u"-";
+    table[4][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
+    table[5][standIdx] = u"+";
+    table[5][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
+    table[6][standIdx] = u";";
+    table[6][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol);
+    table[7][standIdx] = u"@";
+    table[7][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kSignificantDigitSymbol);
+    table[8][standIdx] = u"E";
+    table[8][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kExponentialSymbol);
+    table[9][standIdx] = u"*";
+    table[9][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kPadEscapeSymbol);
+    table[10][standIdx] = u"#";
+    table[10][localIdx] = symbols.getConstSymbol(DecimalFormatSymbols::kDigitSymbol);
+    for (int i = 0; i < 10; i++) {
+        table[11 + i][standIdx] = u'0' + i;
+        table[11 + i][localIdx] = symbols.getConstDigitSymbol(i);
+    }
+
+    // Special case: quotes are NOT allowed to be in any localIdx strings.
+    // Substitute them with '’' instead.
+    for (int32_t i = 0; i < LEN; i++) {
+        table[i][localIdx].findAndReplace(u'\'', u'’');
+    }
+
+    // Iterate through the string and convert.
+    // State table:
+    // 0 => base state
+    // 1 => first char inside a quoted sequence in input and output string
+    // 2 => inside a quoted sequence in input and output string
+    // 3 => first char after a close quote in input string;
+    // close quote still needs to be written to output string
+    // 4 => base state in input string; inside quoted sequence in output string
+    // 5 => first char inside a quoted sequence in input string;
+    // inside quoted sequence in output string
+    UnicodeString result;
+    int state = 0;
+    for (int offset = 0; offset < input.length(); offset++) {
+        UChar ch = input.charAt(offset);
+
+        // Handle a quote character (state shift)
+        if (ch == u'\'') {
+            if (state == 0) {
+                result.append(u'\'');
+                state = 1;
+                continue;
+            } else if (state == 1) {
+                result.append(u'\'');
+                state = 0;
+                continue;
+            } else if (state == 2) {
+                state = 3;
+                continue;
+            } else if (state == 3) {
+                result.append(u'\'');
+                result.append(u'\'');
+                state = 1;
+                continue;
+            } else if (state == 4) {
+                state = 5;
+                continue;
+            } else {
+                U_ASSERT(state == 5);
+                result.append(u'\'');
+                result.append(u'\'');
+                state = 4;
+                continue;
+            }
+        }
+
+        if (state == 0 || state == 3 || state == 4) {
+            for (auto& pair : table) {
+                // Perform a greedy match on this symbol string
+                UnicodeString temp = input.tempSubString(offset, pair[0].length());
+                if (temp == pair[0]) {
+                    // Skip ahead past this region for the next iteration
+                    offset += pair[0].length() - 1;
+                    if (state == 3 || state == 4) {
+                        result.append(u'\'');
+                        state = 0;
+                    }
+                    result.append(pair[1]);
+                    goto continue_outer;
+                }
+            }
+            // No replacement found. Check if a special quote is necessary
+            for (auto& pair : table) {
+                UnicodeString temp = input.tempSubString(offset, pair[1].length());
+                if (temp == pair[1]) {
+                    if (state == 0) {
+                        result.append(u'\'');
+                        state = 4;
+                    }
+                    result.append(ch);
+                    goto continue_outer;
+                }
+            }
+            // Still nothing. Copy the char verbatim. (Add a close quote if necessary)
+            if (state == 3 || state == 4) {
+                result.append(u'\'');
+                state = 0;
+            }
+            result.append(ch);
+        } else {
+            U_ASSERT(state == 1 || state == 2 || state == 5);
+            result.append(ch);
+            state = 2;
+        }
+        continue_outer:;
+    }
+    // Resolve final quotes
+    if (state == 3 || state == 4) {
+        result.append(u'\'');
+        state = 0;
+    }
+    if (state != 0) {
+        // Malformed localized pattern: unterminated quote
+        status = U_PATTERN_SYNTAX_ERROR;
+    }
+    return result;
+}
+
+void PatternStringUtils::patternInfoToStringBuilder(const AffixPatternProvider& patternInfo, bool isPrefix,
+                                                    int8_t signum, UNumberSignDisplay signDisplay,
+                                                    StandardPlural::Form plural,
+                                                    bool perMilleReplacesPercent, UnicodeString& output) {
+
+    // Should the output render '+' where '-' would normally appear in the pattern?
+    bool plusReplacesMinusSign = signum != -1 && (
+            signDisplay == UNUM_SIGN_ALWAYS || signDisplay == UNUM_SIGN_ACCOUNTING_ALWAYS || (
+                    signum == 1 && (
+                            signDisplay == UNUM_SIGN_EXCEPT_ZERO ||
+                            signDisplay == UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO))) &&
+                                 patternInfo.positiveHasPlusSign() == false;
+
+    // Should we use the affix from the negative subpattern? (If not, we will use the positive
+    // subpattern.)
+    bool useNegativeAffixPattern = patternInfo.hasNegativeSubpattern() && (
+            signum == -1 || (patternInfo.negativeHasMinusSign() && plusReplacesMinusSign));
+
+    // Resolve the flags for the affix pattern.
+    int flags = 0;
+    if (useNegativeAffixPattern) {
+        flags |= AffixPatternProvider::AFFIX_NEGATIVE_SUBPATTERN;
+    }
+    if (isPrefix) {
+        flags |= AffixPatternProvider::AFFIX_PREFIX;
+    }
+    if (plural != StandardPlural::Form::COUNT) {
+        U_ASSERT(plural == (AffixPatternProvider::AFFIX_PLURAL_MASK & plural));
+        flags |= plural;
+    }
+
+    // Should we prepend a sign to the pattern?
+    bool prependSign;
+    if (!isPrefix || useNegativeAffixPattern) {
+        prependSign = false;
+    } else if (signum == -1) {
+        prependSign = signDisplay != UNUM_SIGN_NEVER;
+    } else {
+        prependSign = plusReplacesMinusSign;
+    }
+
+    // Compute the length of the affix pattern.
+    int length = patternInfo.length(flags) + (prependSign ? 1 : 0);
+
+    // Finally, set the result into the StringBuilder.
+    output.remove();
+    for (int index = 0; index < length; index++) {
+        char16_t candidate;
+        if (prependSign && index == 0) {
+            candidate = u'-';
+        } else if (prependSign) {
+            candidate = patternInfo.charAt(flags, index - 1);
+        } else {
+            candidate = patternInfo.charAt(flags, index);
+        }
+        if (plusReplacesMinusSign && candidate == u'-') {
+            candidate = u'+';
+        }
+        if (perMilleReplacesPercent && candidate == u'%') {
+            candidate = u'‰';
+        }
+        output.append(candidate);
+    }
+}
+
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_patternstring.h b/deps/icu-small/source/i18n/number_patternstring.h
index ec44290d66397c..91e120c16a1a84 100644
--- a/deps/icu-small/source/i18n/number_patternstring.h
+++ b/deps/icu-small/source/i18n/number_patternstring.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_PATTERNSTRING_H__
 #define __NUMBER_PATTERNSTRING_H__
 
@@ -30,7 +30,7 @@ struct U_I18N_API Endpoints {
 
 // Exported as U_I18N_API because it is a public member field of exported ParsedPatternInfo
 struct U_I18N_API ParsedSubpatternInfo {
-    int64_t groupingSizes = 0x0000ffffffff0000L;
+    uint64_t groupingSizes = 0x0000ffffffff0000L;
     int32_t integerLeadingHashSigns = 0;
     int32_t integerTrailingHashSigns = 0;
     int32_t integerNumerals = 0;
@@ -41,7 +41,9 @@ struct U_I18N_API ParsedSubpatternInfo {
     int32_t fractionTotal = 0; // for convenience
     bool hasDecimal = false;
     int32_t widthExceptAffixes = 0;
-    NullableValue<UNumberFormatPadPosition> paddingLocation;
+    // Note: NullableValue causes issues here with std::move.
+    bool hasPadding = false;
+    UNumberFormatPadPosition paddingLocation = UNUM_PAD_BEFORE_PREFIX;
     DecimalQuantity rounding;
     bool exponentHasPlusSign = false;
     int32_t exponentZeros = 0;
@@ -62,17 +64,21 @@ struct U_I18N_API ParsedPatternInfo : public AffixPatternProvider, public UMemor
     ParsedSubpatternInfo positive;
     ParsedSubpatternInfo negative;
 
-    ParsedPatternInfo() : state(this->pattern), currentSubpattern(nullptr) {}
+    ParsedPatternInfo()
+            : state(this->pattern), currentSubpattern(nullptr) {}
 
     ~ParsedPatternInfo() U_OVERRIDE = default;
 
-    static int32_t getLengthFromEndpoints(const Endpoints &endpoints);
+    // Need to declare this explicitly because of the destructor
+    ParsedPatternInfo& operator=(ParsedPatternInfo&& src) U_NOEXCEPT = default;
+
+    static int32_t getLengthFromEndpoints(const Endpoints& endpoints);
 
     char16_t charAt(int32_t flags, int32_t index) const U_OVERRIDE;
 
     int32_t length(int32_t flags) const U_OVERRIDE;
 
-    UnicodeString getString(int32_t flags) const;
+    UnicodeString getString(int32_t flags) const U_OVERRIDE;
 
     bool positiveHasPlusSign() const U_OVERRIDE;
 
@@ -82,16 +88,24 @@ struct U_I18N_API ParsedPatternInfo : public AffixPatternProvider, public UMemor
 
     bool hasCurrencySign() const U_OVERRIDE;
 
-    bool containsSymbolType(AffixPatternType type, UErrorCode &status) const U_OVERRIDE;
+    bool containsSymbolType(AffixPatternType type, UErrorCode& status) const U_OVERRIDE;
 
     bool hasBody() const U_OVERRIDE;
 
   private:
     struct U_I18N_API ParserState {
-        const UnicodeString &pattern; // reference to the parent
+        const UnicodeString& pattern; // reference to the parent
         int32_t offset = 0;
 
-        explicit ParserState(const UnicodeString &_pattern) : pattern(_pattern) {};
+        explicit ParserState(const UnicodeString& _pattern)
+                : pattern(_pattern) {};
+
+        ParserState& operator=(ParserState&& src) U_NOEXCEPT {
+            // Leave pattern reference alone; it will continue to point to the same place in memory,
+            // which gets overwritten by ParsedPatternInfo's implicit move assignment.
+            offset = src.offset;
+            return *this;
+        }
 
         UChar32 peek();
 
@@ -99,45 +113,48 @@ struct U_I18N_API ParsedPatternInfo : public AffixPatternProvider, public UMemor
 
         // TODO: We don't currently do anything with the message string.
         // This method is here as a shell for Java compatibility.
-        inline void toParseException(const char16_t *message) { (void)message; }
-    }
-    state;
+        inline void toParseException(const char16_t* message) { (void) message; }
+    } state;
 
     // NOTE: In Java, these are written as pure functions.
     // In C++, they're written as methods.
     // The behavior is the same.
 
     // Mutable transient pointer:
-    ParsedSubpatternInfo *currentSubpattern;
+    ParsedSubpatternInfo* currentSubpattern;
 
     // In Java, "negative == null" tells us whether or not we had a negative subpattern.
     // In C++, we need to remember in another boolean.
     bool fHasNegativeSubpattern = false;
 
-    const Endpoints &getEndpoints(int32_t flags) const;
+    const Endpoints& getEndpoints(int32_t flags) const;
 
     /** Run the recursive descent parser. */
-    void consumePattern(const UnicodeString &patternString, UErrorCode &status);
+    void consumePattern(const UnicodeString& patternString, UErrorCode& status);
 
-    void consumeSubpattern(UErrorCode &status);
+    void consumeSubpattern(UErrorCode& status);
 
-    void consumePadding(PadPosition paddingLocation, UErrorCode &status);
+    void consumePadding(PadPosition paddingLocation, UErrorCode& status);
 
-    void consumeAffix(Endpoints &endpoints, UErrorCode &status);
+    void consumeAffix(Endpoints& endpoints, UErrorCode& status);
 
-    void consumeLiteral(UErrorCode &status);
+    void consumeLiteral(UErrorCode& status);
 
-    void consumeFormat(UErrorCode &status);
+    void consumeFormat(UErrorCode& status);
 
-    void consumeIntegerFormat(UErrorCode &status);
+    void consumeIntegerFormat(UErrorCode& status);
 
-    void consumeFractionFormat(UErrorCode &status);
+    void consumeFractionFormat(UErrorCode& status);
 
-    void consumeExponent(UErrorCode &status);
+    void consumeExponent(UErrorCode& status);
 
     friend class PatternParser;
 };
 
+enum IgnoreRounding {
+    IGNORE_ROUNDING_NEVER = 0, IGNORE_ROUNDING_IF_CURRENCY = 1, IGNORE_ROUNDING_ALWAYS = 2
+};
+
 class U_I18N_API PatternParser {
   public:
     /**
@@ -153,12 +170,8 @@ class U_I18N_API PatternParser {
      *            The LDML decimal format pattern (Excel-style pattern) to parse.
      * @return The results of the parse.
      */
-    static void
-    parseToPatternInfo(const UnicodeString& patternString, ParsedPatternInfo &patternInfo, UErrorCode &status);
-
-    enum IgnoreRounding {
-        IGNORE_ROUNDING_NEVER = 0, IGNORE_ROUNDING_IF_CURRENCY = 1, IGNORE_ROUNDING_ALWAYS = 2
-    };
+    static void parseToPatternInfo(const UnicodeString& patternString, ParsedPatternInfo& patternInfo,
+                                   UErrorCode& status);
 
     /**
      * Parses a pattern string into a new property bag.
@@ -173,8 +186,10 @@ class U_I18N_API PatternParser {
      * @throws IllegalArgumentException
      *             If there is a syntax error in the pattern string.
      */
-    static DecimalFormatProperties
-    parseToProperties(const UnicodeString& pattern, IgnoreRounding ignoreRounding, UErrorCode &status);
+    static DecimalFormatProperties parseToProperties(const UnicodeString& pattern,
+                                                     IgnoreRounding ignoreRounding, UErrorCode& status);
+
+    static DecimalFormatProperties parseToProperties(const UnicodeString& pattern, UErrorCode& status);
 
     /**
      * Parses a pattern string into an existing property bag. All properties that can be encoded into a pattern string
@@ -190,18 +205,19 @@ class U_I18N_API PatternParser {
      * @throws IllegalArgumentException
      *             If there was a syntax error in the pattern string.
      */
-    static void parseToExistingProperties(const UnicodeString& pattern, DecimalFormatProperties& properties,
-                                          IgnoreRounding ignoreRounding, UErrorCode &status);
+    static void parseToExistingProperties(const UnicodeString& pattern,
+                                          DecimalFormatProperties& properties,
+                                          IgnoreRounding ignoreRounding, UErrorCode& status);
 
   private:
-    static void
-    parseToExistingPropertiesImpl(const UnicodeString& pattern, DecimalFormatProperties &properties,
-                                  IgnoreRounding ignoreRounding, UErrorCode &status);
+    static void parseToExistingPropertiesImpl(const UnicodeString& pattern,
+                                              DecimalFormatProperties& properties,
+                                              IgnoreRounding ignoreRounding, UErrorCode& status);
 
     /** Finalizes the temporary data stored in the ParsedPatternInfo to the Properties. */
-    static void
-    patternInfoToProperties(DecimalFormatProperties &properties, ParsedPatternInfo& patternInfo,
-                            IgnoreRounding _ignoreRounding, UErrorCode &status);
+    static void patternInfoToProperties(DecimalFormatProperties& properties,
+                                        ParsedPatternInfo& patternInfo, IgnoreRounding _ignoreRounding,
+                                        UErrorCode& status);
 };
 
 class U_I18N_API PatternStringUtils {
@@ -217,8 +233,8 @@ class U_I18N_API PatternStringUtils {
      *            The property bag to serialize.
      * @return A pattern string approximately serializing the property bag.
      */
-    static UnicodeString
-    propertiesToPatternString(const DecimalFormatProperties &properties, UErrorCode &status);
+    static UnicodeString propertiesToPatternString(const DecimalFormatProperties& properties,
+                                                   UErrorCode& status);
 
 
     /**
@@ -248,14 +264,23 @@ class U_I18N_API PatternStringUtils {
      *            notation.
      * @return The pattern expressed in the other notation.
      */
-    static UnicodeString
-    convertLocalized(UnicodeString input, DecimalFormatSymbols symbols, bool toLocalized,
-                     UErrorCode &status);
+    static UnicodeString convertLocalized(const UnicodeString& input, const DecimalFormatSymbols& symbols,
+                                          bool toLocalized, UErrorCode& status);
+
+    /**
+     * This method contains the heart of the logic for rendering LDML affix strings. It handles
+     * sign-always-shown resolution, whether to use the positive or negative subpattern, permille
+     * substitution, and plural forms for CurrencyPluralInfo.
+     */
+    static void patternInfoToStringBuilder(const AffixPatternProvider& patternInfo, bool isPrefix,
+                                           int8_t signum, UNumberSignDisplay signDisplay,
+                                           StandardPlural::Form plural, bool perMilleReplacesPercent,
+                                           UnicodeString& output);
 
   private:
     /** @return The number of chars inserted. */
-    static int
-    escapePaddingString(UnicodeString input, UnicodeString &output, int startIndex, UErrorCode &status);
+    static int escapePaddingString(UnicodeString input, UnicodeString& output, int startIndex,
+                                   UErrorCode& status);
 };
 
 } // namespace impl
diff --git a/deps/icu-small/source/i18n/number_rounding.cpp b/deps/icu-small/source/i18n/number_rounding.cpp
index fd4dafdf983b61..ae4b8849fbe956 100644
--- a/deps/icu-small/source/i18n/number_rounding.cpp
+++ b/deps/icu-small/source/i18n/number_rounding.cpp
@@ -3,17 +3,23 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "uassert.h"
 #include "unicode/numberformatter.h"
 #include "number_types.h"
 #include "number_decimalquantity.h"
+#include "double-conversion.h"
+#include "number_roundingutils.h"
+#include "putilimp.h"
 
 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;
 
+
+using double_conversion::DoubleToStringConverter;
+
 namespace {
 
 int32_t getRoundingMagnitudeFraction(int maxFrac) {
@@ -46,15 +52,38 @@ int32_t getDisplayMagnitudeSignificant(const DecimalQuantity &value, int minSig)
 }
 
 
-Rounder Rounder::unlimited() {
-    return Rounder(RND_NONE, {}, kDefaultMode);
+MultiplierProducer::~MultiplierProducer() = default;
+
+
+digits_t roundingutils::doubleFractionLength(double input) {
+    char buffer[DoubleToStringConverter::kBase10MaximalLength + 1];
+    bool sign; // unused; always positive
+    int32_t length;
+    int32_t point;
+    DoubleToStringConverter::DoubleToAscii(
+            input,
+            DoubleToStringConverter::DtoaMode::SHORTEST,
+            0,
+            buffer,
+            sizeof(buffer),
+            &sign,
+            &length,
+            &point
+    );
+
+    return static_cast<digits_t>(length - point);
 }
 
-FractionRounder Rounder::integer() {
+
+Precision Precision::unlimited() {
+    return Precision(RND_NONE, {}, kDefaultMode);
+}
+
+FractionPrecision Precision::integer() {
     return constructFraction(0, 0);
 }
 
-FractionRounder Rounder::fixedFraction(int32_t minMaxFractionPlaces) {
+FractionPrecision Precision::fixedFraction(int32_t minMaxFractionPlaces) {
     if (minMaxFractionPlaces >= 0 && minMaxFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(minMaxFractionPlaces, minMaxFractionPlaces);
     } else {
@@ -62,7 +91,7 @@ FractionRounder Rounder::fixedFraction(int32_t minMaxFractionPlaces) {
     }
 }
 
-FractionRounder Rounder::minFraction(int32_t minFractionPlaces) {
+FractionPrecision Precision::minFraction(int32_t minFractionPlaces) {
     if (minFractionPlaces >= 0 && minFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(minFractionPlaces, -1);
     } else {
@@ -70,7 +99,7 @@ FractionRounder Rounder::minFraction(int32_t minFractionPlaces) {
     }
 }
 
-FractionRounder Rounder::maxFraction(int32_t maxFractionPlaces) {
+FractionPrecision Precision::maxFraction(int32_t maxFractionPlaces) {
     if (maxFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(0, maxFractionPlaces);
     } else {
@@ -78,7 +107,7 @@ FractionRounder Rounder::maxFraction(int32_t maxFractionPlaces) {
     }
 }
 
-FractionRounder Rounder::minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces) {
+FractionPrecision Precision::minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces) {
     if (minFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig &&
         minFractionPlaces <= maxFractionPlaces) {
         return constructFraction(minFractionPlaces, maxFractionPlaces);
@@ -87,7 +116,7 @@ FractionRounder Rounder::minMaxFraction(int32_t minFractionPlaces, int32_t maxFr
     }
 }
 
-Rounder Rounder::fixedDigits(int32_t minMaxSignificantDigits) {
+Precision Precision::fixedSignificantDigits(int32_t minMaxSignificantDigits) {
     if (minMaxSignificantDigits >= 1 && minMaxSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(minMaxSignificantDigits, minMaxSignificantDigits);
     } else {
@@ -95,7 +124,7 @@ Rounder Rounder::fixedDigits(int32_t minMaxSignificantDigits) {
     }
 }
 
-Rounder Rounder::minDigits(int32_t minSignificantDigits) {
+Precision Precision::minSignificantDigits(int32_t minSignificantDigits) {
     if (minSignificantDigits >= 1 && minSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(minSignificantDigits, -1);
     } else {
@@ -103,7 +132,7 @@ Rounder Rounder::minDigits(int32_t minSignificantDigits) {
     }
 }
 
-Rounder Rounder::maxDigits(int32_t maxSignificantDigits) {
+Precision Precision::maxSignificantDigits(int32_t maxSignificantDigits) {
     if (maxSignificantDigits >= 1 && maxSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(1, maxSignificantDigits);
     } else {
@@ -111,7 +140,7 @@ Rounder Rounder::maxDigits(int32_t maxSignificantDigits) {
     }
 }
 
-Rounder Rounder::minMaxDigits(int32_t minSignificantDigits, int32_t maxSignificantDigits) {
+Precision Precision::minMaxSignificantDigits(int32_t minSignificantDigits, int32_t maxSignificantDigits) {
     if (minSignificantDigits >= 1 && maxSignificantDigits <= kMaxIntFracSig &&
         minSignificantDigits <= maxSignificantDigits) {
         return constructSignificant(minSignificantDigits, maxSignificantDigits);
@@ -120,7 +149,7 @@ Rounder Rounder::minMaxDigits(int32_t minSignificantDigits, int32_t maxSignifica
     }
 }
 
-IncrementRounder Rounder::increment(double roundingIncrement) {
+IncrementPrecision Precision::increment(double roundingIncrement) {
     if (roundingIncrement > 0.0) {
         return constructIncrement(roundingIncrement, 0);
     } else {
@@ -128,16 +157,18 @@ IncrementRounder Rounder::increment(double roundingIncrement) {
     }
 }
 
-CurrencyRounder Rounder::currency(UCurrencyUsage currencyUsage) {
+CurrencyPrecision Precision::currency(UCurrencyUsage currencyUsage) {
     return constructCurrency(currencyUsage);
 }
 
-Rounder Rounder::withMode(RoundingMode roundingMode) const {
+Precision Precision::withMode(RoundingMode roundingMode) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
-    return {fType, fUnion, roundingMode};
+    Precision retval = *this;
+    retval.fRoundingMode = roundingMode;
+    return retval;
 }
 
-Rounder FractionRounder::withMinDigits(int32_t minSignificantDigits) const {
+Precision FractionPrecision::withMinDigits(int32_t minSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (minSignificantDigits >= 1 && minSignificantDigits <= kMaxIntFracSig) {
         return constructFractionSignificant(*this, minSignificantDigits, -1);
@@ -146,7 +177,7 @@ Rounder FractionRounder::withMinDigits(int32_t minSignificantDigits) const {
     }
 }
 
-Rounder FractionRounder::withMaxDigits(int32_t maxSignificantDigits) const {
+Precision FractionPrecision::withMaxDigits(int32_t maxSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (maxSignificantDigits >= 1 && maxSignificantDigits <= kMaxIntFracSig) {
         return constructFractionSignificant(*this, -1, maxSignificantDigits);
@@ -156,7 +187,7 @@ Rounder FractionRounder::withMaxDigits(int32_t maxSignificantDigits) const {
 }
 
 // Private method on base class
-Rounder Rounder::withCurrency(const CurrencyUnit &currency, UErrorCode &status) const {
+Precision Precision::withCurrency(const CurrencyUnit &currency, UErrorCode &status) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     U_ASSERT(fType == RND_CURRENCY);
     const char16_t *isoCode = currency.getISOCurrency();
@@ -170,17 +201,17 @@ Rounder Rounder::withCurrency(const CurrencyUnit &currency, UErrorCode &status)
     }
 }
 
-// Public method on CurrencyRounder subclass
-Rounder CurrencyRounder::withCurrency(const CurrencyUnit &currency) const {
+// Public method on CurrencyPrecision subclass
+Precision CurrencyPrecision::withCurrency(const CurrencyUnit &currency) const {
     UErrorCode localStatus = U_ZERO_ERROR;
-    Rounder result = Rounder::withCurrency(currency, localStatus);
+    Precision result = Precision::withCurrency(currency, localStatus);
     if (U_FAILURE(localStatus)) {
         return {localStatus};
     }
     return result;
 }
 
-Rounder IncrementRounder::withMinFraction(int32_t minFrac) const {
+Precision IncrementPrecision::withMinFraction(int32_t minFrac) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (minFrac >= 0 && minFrac <= kMaxIntFracSig) {
         return constructIncrement(fUnion.increment.fIncrement, minFrac);
@@ -189,67 +220,77 @@ Rounder IncrementRounder::withMinFraction(int32_t minFrac) const {
     }
 }
 
-FractionRounder Rounder::constructFraction(int32_t minFrac, int32_t maxFrac) {
+FractionPrecision Precision::constructFraction(int32_t minFrac, int32_t maxFrac) {
     FractionSignificantSettings settings;
     settings.fMinFrac = static_cast<digits_t>(minFrac);
     settings.fMaxFrac = static_cast<digits_t>(maxFrac);
     settings.fMinSig = -1;
     settings.fMaxSig = -1;
-    RounderUnion union_;
+    PrecisionUnion union_;
     union_.fracSig = settings;
     return {RND_FRACTION, union_, kDefaultMode};
 }
 
-Rounder Rounder::constructSignificant(int32_t minSig, int32_t maxSig) {
+Precision Precision::constructSignificant(int32_t minSig, int32_t maxSig) {
     FractionSignificantSettings settings;
     settings.fMinFrac = -1;
     settings.fMaxFrac = -1;
     settings.fMinSig = static_cast<digits_t>(minSig);
     settings.fMaxSig = static_cast<digits_t>(maxSig);
-    RounderUnion union_;
+    PrecisionUnion union_;
     union_.fracSig = settings;
     return {RND_SIGNIFICANT, union_, kDefaultMode};
 }
 
-Rounder
-Rounder::constructFractionSignificant(const FractionRounder &base, int32_t minSig, int32_t maxSig) {
+Precision
+Precision::constructFractionSignificant(const FractionPrecision &base, int32_t minSig, int32_t maxSig) {
     FractionSignificantSettings settings = base.fUnion.fracSig;
     settings.fMinSig = static_cast<digits_t>(minSig);
     settings.fMaxSig = static_cast<digits_t>(maxSig);
-    RounderUnion union_;
+    PrecisionUnion union_;
     union_.fracSig = settings;
     return {RND_FRACTION_SIGNIFICANT, union_, kDefaultMode};
 }
 
-IncrementRounder Rounder::constructIncrement(double increment, int32_t minFrac) {
+IncrementPrecision Precision::constructIncrement(double increment, int32_t minFrac) {
     IncrementSettings settings;
     settings.fIncrement = increment;
     settings.fMinFrac = static_cast<digits_t>(minFrac);
-    RounderUnion union_;
+    // One of the few pre-computed quantities:
+    // Note: it is possible for minFrac to be more than maxFrac... (misleading)
+    settings.fMaxFrac = roundingutils::doubleFractionLength(increment);
+    PrecisionUnion union_;
     union_.increment = settings;
     return {RND_INCREMENT, union_, kDefaultMode};
 }
 
-CurrencyRounder Rounder::constructCurrency(UCurrencyUsage usage) {
-    RounderUnion union_;
+CurrencyPrecision Precision::constructCurrency(UCurrencyUsage usage) {
+    PrecisionUnion union_;
     union_.currencyUsage = usage;
     return {RND_CURRENCY, union_, kDefaultMode};
 }
 
-Rounder Rounder::constructPassThrough() {
-    RounderUnion union_;
-    union_.errorCode = U_ZERO_ERROR; // initialize the variable
-    return {RND_PASS_THROUGH, union_, kDefaultMode};
-}
 
-void Rounder::setLocaleData(const CurrencyUnit &currency, UErrorCode &status) {
-    if (fType == RND_CURRENCY) {
-        *this = withCurrency(currency, status);
+RoundingImpl::RoundingImpl(const Precision& precision, UNumberFormatRoundingMode roundingMode,
+                           const CurrencyUnit& currency, UErrorCode& status)
+        : fPrecision(precision), fRoundingMode(roundingMode), fPassThrough(false) {
+    if (precision.fType == Precision::RND_CURRENCY) {
+        fPrecision = precision.withCurrency(currency, status);
     }
 }
 
+RoundingImpl RoundingImpl::passThrough() {
+    RoundingImpl retval;
+    retval.fPassThrough = true;
+    return retval;
+}
+
+bool RoundingImpl::isSignificantDigits() const {
+    return fPrecision.fType == Precision::RND_SIGNIFICANT;
+}
+
 int32_t
-Rounder::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
+RoundingImpl::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
                                   UErrorCode &status) {
     // Do not call this method with zero.
     U_ASSERT(!input.isZero());
@@ -287,45 +328,59 @@ Rounder::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::Mult
 }
 
 /** This is the method that contains the actual rounding logic. */
-void Rounder::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
-    switch (fType) {
-        case RND_BOGUS:
-        case RND_ERROR:
+void RoundingImpl::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
+    if (fPassThrough) {
+        return;
+    }
+    switch (fPrecision.fType) {
+        case Precision::RND_BOGUS:
+        case Precision::RND_ERROR:
             // Errors should be caught before the apply() method is called
             status = U_INTERNAL_PROGRAM_ERROR;
             break;
 
-        case RND_NONE:
+        case Precision::RND_NONE:
             value.roundToInfinity();
             break;
 
-        case RND_FRACTION:
+        case Precision::RND_FRACTION:
             value.roundToMagnitude(
-                    getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac), fRoundingMode, status);
+                    getRoundingMagnitudeFraction(fPrecision.fUnion.fracSig.fMaxFrac),
+                    fRoundingMode,
+                    status);
             value.setFractionLength(
-                    uprv_max(0, -getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac)), INT32_MAX);
+                    uprv_max(0, -getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac)),
+                    INT32_MAX);
             break;
 
-        case RND_SIGNIFICANT:
+        case Precision::RND_SIGNIFICANT:
             value.roundToMagnitude(
-                    getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig),
+                    getRoundingMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMaxSig),
                     fRoundingMode,
                     status);
             value.setFractionLength(
-                    uprv_max(0, -getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig)),
+                    uprv_max(0, -getDisplayMagnitudeSignificant(value, fPrecision.fUnion.fracSig.fMinSig)),
                     INT32_MAX);
+            // Make sure that digits are displayed on zero.
+            if (value.isZero() && fPrecision.fUnion.fracSig.fMinSig > 0) {
+                value.setIntegerLength(1, INT32_MAX);
+            }
             break;
 
-        case RND_FRACTION_SIGNIFICANT: {
-            int32_t displayMag = getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac);
-            int32_t roundingMag = getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac);
-            if (fUnion.fracSig.fMinSig == -1) {
+        case Precision::RND_FRACTION_SIGNIFICANT: {
+            int32_t displayMag = getDisplayMagnitudeFraction(fPrecision.fUnion.fracSig.fMinFrac);
+            int32_t roundingMag = getRoundingMagnitudeFraction(fPrecision.fUnion.fracSig.fMaxFrac);
+            if (fPrecision.fUnion.fracSig.fMinSig == -1) {
                 // Max Sig override
-                int32_t candidate = getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig);
+                int32_t candidate = getRoundingMagnitudeSignificant(
+                        value,
+                        fPrecision.fUnion.fracSig.fMaxSig);
                 roundingMag = uprv_max(roundingMag, candidate);
             } else {
                 // Min Sig override
-                int32_t candidate = getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig);
+                int32_t candidate = getDisplayMagnitudeSignificant(
+                        value,
+                        fPrecision.fUnion.fracSig.fMinSig);
                 roundingMag = uprv_min(roundingMag, candidate);
             }
             value.roundToMagnitude(roundingMag, fRoundingMode, status);
@@ -333,27 +388,27 @@ void Rounder::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
             break;
         }
 
-        case RND_INCREMENT:
+        case Precision::RND_INCREMENT:
             value.roundToIncrement(
-                fUnion.increment.fIncrement, fRoundingMode, fUnion.increment.fMinFrac, status);
-            value.setFractionLength(fUnion.increment.fMinFrac, fUnion.increment.fMinFrac);
+                    fPrecision.fUnion.increment.fIncrement,
+                    fRoundingMode,
+                    fPrecision.fUnion.increment.fMaxFrac,
+                    status);
+            value.setFractionLength(fPrecision.fUnion.increment.fMinFrac, INT32_MAX);
             break;
 
-        case RND_CURRENCY:
+        case Precision::RND_CURRENCY:
             // Call .withCurrency() before .apply()!
             U_ASSERT(false);
             break;
-
-        case RND_PASS_THROUGH:
-            break;
     }
 }
 
-void Rounder::apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode /*status*/) {
+void RoundingImpl::apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode /*status*/) {
     // This method is intended for the one specific purpose of helping print "00.000E0".
-    U_ASSERT(fType == RND_SIGNIFICANT);
+    U_ASSERT(isSignificantDigits());
     U_ASSERT(value.isZero());
-    value.setFractionLength(fUnion.fracSig.fMinSig - minInt, INT32_MAX);
+    value.setFractionLength(fPrecision.fUnion.fracSig.fMinSig - minInt, INT32_MAX);
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_roundingutils.h b/deps/icu-small/source/i18n/number_roundingutils.h
index 6868ee0b86817e..66d58bb775bbee 100644
--- a/deps/icu-small/source/i18n/number_roundingutils.h
+++ b/deps/icu-small/source/i18n/number_roundingutils.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_ROUNDINGUTILS_H__
 #define __NUMBER_ROUNDINGUTILS_H__
 
@@ -131,7 +131,62 @@ inline bool roundsAtMidpoint(int roundingMode) {
     }
 }
 
+/**
+ * Computes the number of fraction digits in a double. Used for computing maxFrac for an increment.
+ * Calls into the DoubleToStringConverter library to do so.
+ */
+digits_t doubleFractionLength(double input);
+
 } // namespace roundingutils
+
+
+/**
+ * Encapsulates a Precision and a RoundingMode and performs rounding on a DecimalQuantity.
+ *
+ * This class does not exist in Java: instead, the base Precision class is used.
+ */
+class RoundingImpl {
+  public:
+    RoundingImpl() = default;  // default constructor: leaves object in undefined state
+
+    RoundingImpl(const Precision& precision, UNumberFormatRoundingMode roundingMode,
+                 const CurrencyUnit& currency, UErrorCode& status);
+
+    static RoundingImpl passThrough();
+
+    /** Required for ScientificFormatter */
+    bool isSignificantDigits() const;
+
+    /**
+     * Rounding endpoint used by Engineering and Compact notation. Chooses the most appropriate multiplier (magnitude
+     * adjustment), applies the adjustment, rounds, and returns the chosen multiplier.
+     *
+     * <p>
+     * In most cases, this is simple. However, when rounding the number causes it to cross a multiplier boundary, we
+     * need to re-do the rounding. For example, to display 999,999 in Engineering notation with 2 sigfigs, first you
+     * guess the multiplier to be -3. However, then you end up getting 1000E3, which is not the correct output. You then
+     * change your multiplier to be -6, and you get 1.0E6, which is correct.
+     *
+     * @param input The quantity to process.
+     * @param producer Function to call to return a multiplier based on a magnitude.
+     * @return The number of orders of magnitude the input was adjusted by this method.
+     */
+    int32_t
+    chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
+                             UErrorCode &status);
+
+    void apply(impl::DecimalQuantity &value, UErrorCode &status) const;
+
+    /** Version of {@link #apply} that obeys minInt constraints. Used for scientific notation compatibility mode. */
+    void apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode status);
+
+  private:
+    Precision fPrecision;
+    UNumberFormatRoundingMode fRoundingMode;
+    bool fPassThrough;
+};
+
+
 } // namespace impl
 } // namespace number
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/number_scientific.cpp b/deps/icu-small/source/i18n/number_scientific.cpp
index a2f2bf85a1fc9d..40952024e995cc 100644
--- a/deps/icu-small/source/i18n/number_scientific.cpp
+++ b/deps/icu-small/source/i18n/number_scientific.cpp
@@ -3,13 +3,14 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include <cstdlib>
 #include "number_scientific.h"
 #include "number_utils.h"
 #include "number_stringbuilder.h"
 #include "unicode/unum.h"
+#include "number_microprops.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -64,8 +65,13 @@ int32_t ScientificModifier::apply(NumberStringBuilder &output, int32_t /*leftInd
     int32_t disp = std::abs(fExponent);
     for (int j = 0; j < fHandler->fSettings.fMinExponentDigits || disp > 0; j++, disp /= 10) {
         auto d = static_cast<int8_t>(disp % 10);
-        const UnicodeString &digitString = getDigitFromSymbols(d, *fHandler->fSymbols);
-        i += output.insert(i - j, digitString, UNUM_EXPONENT_FIELD, status);
+        i += utils::insertDigitFromSymbols(
+                output,
+                i - j,
+                d,
+                *fHandler->fSymbols,
+                UNUM_EXPONENT_FIELD,
+                status);
     }
     return i - rightIndex;
 }
@@ -101,22 +107,25 @@ void ScientificHandler::processQuantity(DecimalQuantity &quantity, MicroProps &m
     // Treat zero as if it had magnitude 0
     int32_t exponent;
     if (quantity.isZero()) {
-        if (fSettings.fRequireMinInt && micros.rounding.fType == Rounder::RND_SIGNIFICANT) {
+        if (fSettings.fRequireMinInt && micros.rounder.isSignificantDigits()) {
             // Show "00.000E0" on pattern "00.000E0"
-            micros.rounding.apply(quantity, fSettings.fEngineeringInterval, status);
+            micros.rounder.apply(quantity, fSettings.fEngineeringInterval, status);
             exponent = 0;
         } else {
-            micros.rounding.apply(quantity, status);
+            micros.rounder.apply(quantity, status);
             exponent = 0;
         }
     } else {
-        exponent = -micros.rounding.chooseMultiplierAndApply(quantity, *this, status);
+        exponent = -micros.rounder.chooseMultiplierAndApply(quantity, *this, status);
     }
 
     // Use MicroProps's helper ScientificModifier and save it as the modInner.
     ScientificModifier &mod = micros.helpers.scientificModifier;
     mod.set(exponent, this);
     micros.modInner = &mod;
+
+    // We already performed rounding. Do not perform it again.
+    micros.rounder = RoundingImpl::passThrough();
 }
 
 int32_t ScientificHandler::getMultiplier(int32_t magnitude) const {
diff --git a/deps/icu-small/source/i18n/number_scientific.h b/deps/icu-small/source/i18n/number_scientific.h
index f5e4d30e6a9737..974ab3adb614ca 100644
--- a/deps/icu-small/source/i18n/number_scientific.h
+++ b/deps/icu-small/source/i18n/number_scientific.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_SCIENTIFIC_H__
 #define __NUMBER_SCIENTIFIC_H__
 
diff --git a/deps/icu-small/source/i18n/number_skeletons.cpp b/deps/icu-small/source/i18n/number_skeletons.cpp
new file mode 100644
index 00000000000000..c7bb18b5f3d2b5
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_skeletons.cpp
@@ -0,0 +1,1510 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "number_decnum.h"
+#include "number_skeletons.h"
+#include "umutex.h"
+#include "ucln_in.h"
+#include "patternprops.h"
+#include "unicode/ucharstriebuilder.h"
+#include "number_utils.h"
+#include "number_decimalquantity.h"
+#include "unicode/numberformatter.h"
+#include "uinvchar.h"
+#include "charstr.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using namespace icu::number::impl::skeleton;
+
+namespace {
+
+icu::UInitOnce gNumberSkeletonsInitOnce = U_INITONCE_INITIALIZER;
+
+char16_t* kSerializedStemTrie = nullptr;
+
+UBool U_CALLCONV cleanupNumberSkeletons() {
+    uprv_free(kSerializedStemTrie);
+    kSerializedStemTrie = nullptr;
+    gNumberSkeletonsInitOnce.reset();
+    return TRUE;
+}
+
+void U_CALLCONV initNumberSkeletons(UErrorCode& status) {
+    ucln_i18n_registerCleanup(UCLN_I18N_NUMBER_SKELETONS, cleanupNumberSkeletons);
+
+    UCharsTrieBuilder b(status);
+    if (U_FAILURE(status)) { return; }
+
+    // Section 1:
+    b.add(u"compact-short", STEM_COMPACT_SHORT, status);
+    b.add(u"compact-long", STEM_COMPACT_LONG, status);
+    b.add(u"scientific", STEM_SCIENTIFIC, status);
+    b.add(u"engineering", STEM_ENGINEERING, status);
+    b.add(u"notation-simple", STEM_NOTATION_SIMPLE, status);
+    b.add(u"base-unit", STEM_BASE_UNIT, status);
+    b.add(u"percent", STEM_PERCENT, status);
+    b.add(u"permille", STEM_PERMILLE, status);
+    b.add(u"precision-integer", STEM_PRECISION_INTEGER, status);
+    b.add(u"precision-unlimited", STEM_PRECISION_UNLIMITED, status);
+    b.add(u"precision-currency-standard", STEM_PRECISION_CURRENCY_STANDARD, status);
+    b.add(u"precision-currency-cash", STEM_PRECISION_CURRENCY_CASH, status);
+    b.add(u"rounding-mode-ceiling", STEM_ROUNDING_MODE_CEILING, status);
+    b.add(u"rounding-mode-floor", STEM_ROUNDING_MODE_FLOOR, status);
+    b.add(u"rounding-mode-down", STEM_ROUNDING_MODE_DOWN, status);
+    b.add(u"rounding-mode-up", STEM_ROUNDING_MODE_UP, status);
+    b.add(u"rounding-mode-half-even", STEM_ROUNDING_MODE_HALF_EVEN, status);
+    b.add(u"rounding-mode-half-down", STEM_ROUNDING_MODE_HALF_DOWN, status);
+    b.add(u"rounding-mode-half-up", STEM_ROUNDING_MODE_HALF_UP, status);
+    b.add(u"rounding-mode-unnecessary", STEM_ROUNDING_MODE_UNNECESSARY, status);
+    b.add(u"group-off", STEM_GROUP_OFF, status);
+    b.add(u"group-min2", STEM_GROUP_MIN2, status);
+    b.add(u"group-auto", STEM_GROUP_AUTO, status);
+    b.add(u"group-on-aligned", STEM_GROUP_ON_ALIGNED, status);
+    b.add(u"group-thousands", STEM_GROUP_THOUSANDS, status);
+    b.add(u"latin", STEM_LATIN, status);
+    b.add(u"unit-width-narrow", STEM_UNIT_WIDTH_NARROW, status);
+    b.add(u"unit-width-short", STEM_UNIT_WIDTH_SHORT, status);
+    b.add(u"unit-width-full-name", STEM_UNIT_WIDTH_FULL_NAME, status);
+    b.add(u"unit-width-iso-code", STEM_UNIT_WIDTH_ISO_CODE, status);
+    b.add(u"unit-width-hidden", STEM_UNIT_WIDTH_HIDDEN, status);
+    b.add(u"sign-auto", STEM_SIGN_AUTO, status);
+    b.add(u"sign-always", STEM_SIGN_ALWAYS, status);
+    b.add(u"sign-never", STEM_SIGN_NEVER, status);
+    b.add(u"sign-accounting", STEM_SIGN_ACCOUNTING, status);
+    b.add(u"sign-accounting-always", STEM_SIGN_ACCOUNTING_ALWAYS, status);
+    b.add(u"sign-except-zero", STEM_SIGN_EXCEPT_ZERO, status);
+    b.add(u"sign-accounting-except-zero", STEM_SIGN_ACCOUNTING_EXCEPT_ZERO, status);
+    b.add(u"decimal-auto", STEM_DECIMAL_AUTO, status);
+    b.add(u"decimal-always", STEM_DECIMAL_ALWAYS, status);
+    if (U_FAILURE(status)) { return; }
+
+    // Section 2:
+    b.add(u"precision-increment", STEM_PRECISION_INCREMENT, status);
+    b.add(u"measure-unit", STEM_MEASURE_UNIT, status);
+    b.add(u"per-measure-unit", STEM_PER_MEASURE_UNIT, status);
+    b.add(u"currency", STEM_CURRENCY, status);
+    b.add(u"integer-width", STEM_INTEGER_WIDTH, status);
+    b.add(u"numbering-system", STEM_NUMBERING_SYSTEM, status);
+    b.add(u"scale", STEM_SCALE, status);
+    if (U_FAILURE(status)) { return; }
+
+    // Build the CharsTrie
+    // TODO: Use SLOW or FAST here?
+    UnicodeString result;
+    b.buildUnicodeString(USTRINGTRIE_BUILD_FAST, result, status);
+    if (U_FAILURE(status)) { return; }
+
+    // Copy the result into the global constant pointer
+    size_t numBytes = result.length() * sizeof(char16_t);
+    kSerializedStemTrie = static_cast<char16_t*>(uprv_malloc(numBytes));
+    uprv_memcpy(kSerializedStemTrie, result.getBuffer(), numBytes);
+}
+
+
+inline void appendMultiple(UnicodeString& sb, UChar32 cp, int32_t count) {
+    for (int i = 0; i < count; i++) {
+        sb.append(cp);
+    }
+}
+
+
+#define CHECK_NULL(seen, field, status) (void)(seen); /* for auto-format line wrapping */ \
+{ \
+    if ((seen).field) { \
+        (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \
+        return STATE_NULL; \
+    } \
+    (seen).field = true; \
+}
+
+
+#define SKELETON_UCHAR_TO_CHAR(dest, src, start, end, status) (void)(dest); \
+{ \
+    UErrorCode conversionStatus = U_ZERO_ERROR; \
+    (dest).appendInvariantChars({FALSE, (src).getBuffer() + (start), (end) - (start)}, conversionStatus); \
+    if (conversionStatus == U_INVARIANT_CONVERSION_ERROR) { \
+        /* Don't propagate the invariant conversion error; it is a skeleton syntax error */ \
+        (status) = U_NUMBER_SKELETON_SYNTAX_ERROR; \
+        return; \
+    } else if (U_FAILURE(conversionStatus)) { \
+        (status) = conversionStatus; \
+        return; \
+    } \
+}
+
+
+} // anonymous namespace
+
+
+Notation stem_to_object::notation(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_COMPACT_SHORT:
+            return Notation::compactShort();
+        case STEM_COMPACT_LONG:
+            return Notation::compactLong();
+        case STEM_SCIENTIFIC:
+            return Notation::scientific();
+        case STEM_ENGINEERING:
+            return Notation::engineering();
+        case STEM_NOTATION_SIMPLE:
+            return Notation::simple();
+        default:
+            U_ASSERT(false);
+            return Notation::simple(); // return a value: silence compiler warning
+    }
+}
+
+MeasureUnit stem_to_object::unit(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_BASE_UNIT:
+            // Slicing is okay
+            return NoUnit::base(); // NOLINT
+        case STEM_PERCENT:
+            // Slicing is okay
+            return NoUnit::percent(); // NOLINT
+        case STEM_PERMILLE:
+            // Slicing is okay
+            return NoUnit::permille(); // NOLINT
+        default:
+            U_ASSERT(false);
+            return {}; // return a value: silence compiler warning
+    }
+}
+
+Precision stem_to_object::precision(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_PRECISION_INTEGER:
+            return Precision::integer();
+        case STEM_PRECISION_UNLIMITED:
+            return Precision::unlimited();
+        case STEM_PRECISION_CURRENCY_STANDARD:
+            return Precision::currency(UCURR_USAGE_STANDARD);
+        case STEM_PRECISION_CURRENCY_CASH:
+            return Precision::currency(UCURR_USAGE_CASH);
+        default:
+            U_ASSERT(false);
+            return Precision::integer(); // return a value: silence compiler warning
+    }
+}
+
+UNumberFormatRoundingMode stem_to_object::roundingMode(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_ROUNDING_MODE_CEILING:
+            return UNUM_ROUND_CEILING;
+        case STEM_ROUNDING_MODE_FLOOR:
+            return UNUM_ROUND_FLOOR;
+        case STEM_ROUNDING_MODE_DOWN:
+            return UNUM_ROUND_DOWN;
+        case STEM_ROUNDING_MODE_UP:
+            return UNUM_ROUND_UP;
+        case STEM_ROUNDING_MODE_HALF_EVEN:
+            return UNUM_ROUND_HALFEVEN;
+        case STEM_ROUNDING_MODE_HALF_DOWN:
+            return UNUM_ROUND_HALFDOWN;
+        case STEM_ROUNDING_MODE_HALF_UP:
+            return UNUM_ROUND_HALFUP;
+        case STEM_ROUNDING_MODE_UNNECESSARY:
+            return UNUM_ROUND_UNNECESSARY;
+        default:
+            U_ASSERT(false);
+            return UNUM_ROUND_UNNECESSARY;
+    }
+}
+
+UGroupingStrategy stem_to_object::groupingStrategy(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_GROUP_OFF:
+            return UNUM_GROUPING_OFF;
+        case STEM_GROUP_MIN2:
+            return UNUM_GROUPING_MIN2;
+        case STEM_GROUP_AUTO:
+            return UNUM_GROUPING_AUTO;
+        case STEM_GROUP_ON_ALIGNED:
+            return UNUM_GROUPING_ON_ALIGNED;
+        case STEM_GROUP_THOUSANDS:
+            return UNUM_GROUPING_THOUSANDS;
+        default:
+            return UNUM_GROUPING_COUNT; // for objects, throw; for enums, return COUNT
+    }
+}
+
+UNumberUnitWidth stem_to_object::unitWidth(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_UNIT_WIDTH_NARROW:
+            return UNUM_UNIT_WIDTH_NARROW;
+        case STEM_UNIT_WIDTH_SHORT:
+            return UNUM_UNIT_WIDTH_SHORT;
+        case STEM_UNIT_WIDTH_FULL_NAME:
+            return UNUM_UNIT_WIDTH_FULL_NAME;
+        case STEM_UNIT_WIDTH_ISO_CODE:
+            return UNUM_UNIT_WIDTH_ISO_CODE;
+        case STEM_UNIT_WIDTH_HIDDEN:
+            return UNUM_UNIT_WIDTH_HIDDEN;
+        default:
+            return UNUM_UNIT_WIDTH_COUNT; // for objects, throw; for enums, return COUNT
+    }
+}
+
+UNumberSignDisplay stem_to_object::signDisplay(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_SIGN_AUTO:
+            return UNUM_SIGN_AUTO;
+        case STEM_SIGN_ALWAYS:
+            return UNUM_SIGN_ALWAYS;
+        case STEM_SIGN_NEVER:
+            return UNUM_SIGN_NEVER;
+        case STEM_SIGN_ACCOUNTING:
+            return UNUM_SIGN_ACCOUNTING;
+        case STEM_SIGN_ACCOUNTING_ALWAYS:
+            return UNUM_SIGN_ACCOUNTING_ALWAYS;
+        case STEM_SIGN_EXCEPT_ZERO:
+            return UNUM_SIGN_EXCEPT_ZERO;
+        case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO:
+            return UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO;
+        default:
+            return UNUM_SIGN_COUNT; // for objects, throw; for enums, return COUNT
+    }
+}
+
+UNumberDecimalSeparatorDisplay stem_to_object::decimalSeparatorDisplay(skeleton::StemEnum stem) {
+    switch (stem) {
+        case STEM_DECIMAL_AUTO:
+            return UNUM_DECIMAL_SEPARATOR_AUTO;
+        case STEM_DECIMAL_ALWAYS:
+            return UNUM_DECIMAL_SEPARATOR_ALWAYS;
+        default:
+            return UNUM_DECIMAL_SEPARATOR_COUNT; // for objects, throw; for enums, return COUNT
+    }
+}
+
+
+void enum_to_stem_string::roundingMode(UNumberFormatRoundingMode value, UnicodeString& sb) {
+    switch (value) {
+        case UNUM_ROUND_CEILING:
+            sb.append(u"rounding-mode-ceiling", -1);
+            break;
+        case UNUM_ROUND_FLOOR:
+            sb.append(u"rounding-mode-floor", -1);
+            break;
+        case UNUM_ROUND_DOWN:
+            sb.append(u"rounding-mode-down", -1);
+            break;
+        case UNUM_ROUND_UP:
+            sb.append(u"rounding-mode-up", -1);
+            break;
+        case UNUM_ROUND_HALFEVEN:
+            sb.append(u"rounding-mode-half-even", -1);
+            break;
+        case UNUM_ROUND_HALFDOWN:
+            sb.append(u"rounding-mode-half-down", -1);
+            break;
+        case UNUM_ROUND_HALFUP:
+            sb.append(u"rounding-mode-half-up", -1);
+            break;
+        case UNUM_ROUND_UNNECESSARY:
+            sb.append(u"rounding-mode-unnecessary", -1);
+            break;
+        default:
+            U_ASSERT(false);
+    }
+}
+
+void enum_to_stem_string::groupingStrategy(UGroupingStrategy value, UnicodeString& sb) {
+    switch (value) {
+        case UNUM_GROUPING_OFF:
+            sb.append(u"group-off", -1);
+            break;
+        case UNUM_GROUPING_MIN2:
+            sb.append(u"group-min2", -1);
+            break;
+        case UNUM_GROUPING_AUTO:
+            sb.append(u"group-auto", -1);
+            break;
+        case UNUM_GROUPING_ON_ALIGNED:
+            sb.append(u"group-on-aligned", -1);
+            break;
+        case UNUM_GROUPING_THOUSANDS:
+            sb.append(u"group-thousands", -1);
+            break;
+        default:
+            U_ASSERT(false);
+    }
+}
+
+void enum_to_stem_string::unitWidth(UNumberUnitWidth value, UnicodeString& sb) {
+    switch (value) {
+        case UNUM_UNIT_WIDTH_NARROW:
+            sb.append(u"unit-width-narrow", -1);
+            break;
+        case UNUM_UNIT_WIDTH_SHORT:
+            sb.append(u"unit-width-short", -1);
+            break;
+        case UNUM_UNIT_WIDTH_FULL_NAME:
+            sb.append(u"unit-width-full-name", -1);
+            break;
+        case UNUM_UNIT_WIDTH_ISO_CODE:
+            sb.append(u"unit-width-iso-code", -1);
+            break;
+        case UNUM_UNIT_WIDTH_HIDDEN:
+            sb.append(u"unit-width-hidden", -1);
+            break;
+        default:
+            U_ASSERT(false);
+    }
+}
+
+void enum_to_stem_string::signDisplay(UNumberSignDisplay value, UnicodeString& sb) {
+    switch (value) {
+        case UNUM_SIGN_AUTO:
+            sb.append(u"sign-auto", -1);
+            break;
+        case UNUM_SIGN_ALWAYS:
+            sb.append(u"sign-always", -1);
+            break;
+        case UNUM_SIGN_NEVER:
+            sb.append(u"sign-never", -1);
+            break;
+        case UNUM_SIGN_ACCOUNTING:
+            sb.append(u"sign-accounting", -1);
+            break;
+        case UNUM_SIGN_ACCOUNTING_ALWAYS:
+            sb.append(u"sign-accounting-always", -1);
+            break;
+        case UNUM_SIGN_EXCEPT_ZERO:
+            sb.append(u"sign-except-zero", -1);
+            break;
+        case UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO:
+            sb.append(u"sign-accounting-except-zero", -1);
+            break;
+        default:
+            U_ASSERT(false);
+    }
+}
+
+void
+enum_to_stem_string::decimalSeparatorDisplay(UNumberDecimalSeparatorDisplay value, UnicodeString& sb) {
+    switch (value) {
+        case UNUM_DECIMAL_SEPARATOR_AUTO:
+            sb.append(u"decimal-auto", -1);
+            break;
+        case UNUM_DECIMAL_SEPARATOR_ALWAYS:
+            sb.append(u"decimal-always", -1);
+            break;
+        default:
+            U_ASSERT(false);
+    }
+}
+
+
+UnlocalizedNumberFormatter skeleton::create(const UnicodeString& skeletonString, UErrorCode& status) {
+    umtx_initOnce(gNumberSkeletonsInitOnce, &initNumberSkeletons, status);
+    MacroProps macros = parseSkeleton(skeletonString, status);
+    return NumberFormatter::with().macros(macros);
+}
+
+UnicodeString skeleton::generate(const MacroProps& macros, UErrorCode& status) {
+    umtx_initOnce(gNumberSkeletonsInitOnce, &initNumberSkeletons, status);
+    UnicodeString sb;
+    GeneratorHelpers::generateSkeleton(macros, sb, status);
+    return sb;
+}
+
+MacroProps skeleton::parseSkeleton(const UnicodeString& skeletonString, UErrorCode& status) {
+    if (U_FAILURE(status)) { return MacroProps(); }
+
+    // Add a trailing whitespace to the end of the skeleton string to make code cleaner.
+    UnicodeString tempSkeletonString(skeletonString);
+    tempSkeletonString.append(u' ');
+
+    SeenMacroProps seen;
+    MacroProps macros;
+    StringSegment segment(tempSkeletonString, false);
+    UCharsTrie stemTrie(kSerializedStemTrie);
+    ParseState stem = STATE_NULL;
+    int32_t offset = 0;
+
+    // Primary skeleton parse loop:
+    while (offset < segment.length()) {
+        UChar32 cp = segment.codePointAt(offset);
+        bool isTokenSeparator = PatternProps::isWhiteSpace(cp);
+        bool isOptionSeparator = (cp == u'/');
+
+        if (!isTokenSeparator && !isOptionSeparator) {
+            // Non-separator token; consume it.
+            offset += U16_LENGTH(cp);
+            if (stem == STATE_NULL) {
+                // We are currently consuming a stem.
+                // Go to the next state in the stem trie.
+                stemTrie.nextForCodePoint(cp);
+            }
+            continue;
+        }
+
+        // We are looking at a token or option separator.
+        // If the segment is nonempty, parse it and reset the segment.
+        // Otherwise, make sure it is a valid repeating separator.
+        if (offset != 0) {
+            segment.setLength(offset);
+            if (stem == STATE_NULL) {
+                // The first separator after the start of a token. Parse it as a stem.
+                stem = parseStem(segment, stemTrie, seen, macros, status);
+                stemTrie.reset();
+            } else {
+                // A separator after the first separator of a token. Parse it as an option.
+                stem = parseOption(stem, segment, macros, status);
+            }
+            segment.resetLength();
+            if (U_FAILURE(status)) { return macros; }
+
+            // Consume the segment:
+            segment.adjustOffset(offset);
+            offset = 0;
+
+        } else if (stem != STATE_NULL) {
+            // A separator ('/' or whitespace) following an option separator ('/')
+            // segment.setLength(U16_LENGTH(cp)); // for error message
+            // throw new SkeletonSyntaxException("Unexpected separator character", segment);
+            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+            return macros;
+
+        } else {
+            // Two spaces in a row; this is OK.
+        }
+
+        // Does the current stem forbid options?
+        if (isOptionSeparator && stem == STATE_NULL) {
+            // segment.setLength(U16_LENGTH(cp)); // for error message
+            // throw new SkeletonSyntaxException("Unexpected option separator", segment);
+            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+            return macros;
+        }
+
+        // Does the current stem require an option?
+        if (isTokenSeparator && stem != STATE_NULL) {
+            switch (stem) {
+                case STATE_INCREMENT_PRECISION:
+                case STATE_MEASURE_UNIT:
+                case STATE_PER_MEASURE_UNIT:
+                case STATE_CURRENCY_UNIT:
+                case STATE_INTEGER_WIDTH:
+                case STATE_NUMBERING_SYSTEM:
+                case STATE_SCALE:
+                    // segment.setLength(U16_LENGTH(cp)); // for error message
+                    // throw new SkeletonSyntaxException("Stem requires an option", segment);
+                    status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+                    return macros;
+                default:
+                    break;
+            }
+            stem = STATE_NULL;
+        }
+
+        // Consume the separator:
+        segment.adjustOffset(U16_LENGTH(cp));
+    }
+    U_ASSERT(stem == STATE_NULL);
+    return macros;
+}
+
+ParseState
+skeleton::parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, SeenMacroProps& seen,
+                    MacroProps& macros, UErrorCode& status) {
+    // First check for "blueprint" stems, which start with a "signal char"
+    switch (segment.charAt(0)) {
+        case u'.':
+        CHECK_NULL(seen, precision, status);
+            blueprint_helpers::parseFractionStem(segment, macros, status);
+            return STATE_FRACTION_PRECISION;
+        case u'@':
+        CHECK_NULL(seen, precision, status);
+            blueprint_helpers::parseDigitsStem(segment, macros, status);
+            return STATE_NULL;
+        default:
+            break;
+    }
+
+    // Now look at the stemsTrie, which is already be pointing at our stem.
+    UStringTrieResult stemResult = stemTrie.current();
+
+    if (stemResult != USTRINGTRIE_INTERMEDIATE_VALUE && stemResult != USTRINGTRIE_FINAL_VALUE) {
+        // throw new SkeletonSyntaxException("Unknown stem", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return STATE_NULL;
+    }
+
+    auto stem = static_cast<StemEnum>(stemTrie.getValue());
+    switch (stem) {
+
+        // Stems with meaning on their own, not requiring an option:
+
+        case STEM_COMPACT_SHORT:
+        case STEM_COMPACT_LONG:
+        case STEM_SCIENTIFIC:
+        case STEM_ENGINEERING:
+        case STEM_NOTATION_SIMPLE:
+        CHECK_NULL(seen, notation, status);
+            macros.notation = stem_to_object::notation(stem);
+            switch (stem) {
+                case STEM_SCIENTIFIC:
+                case STEM_ENGINEERING:
+                    return STATE_SCIENTIFIC; // allows for scientific options
+                default:
+                    return STATE_NULL;
+            }
+
+        case STEM_BASE_UNIT:
+        case STEM_PERCENT:
+        case STEM_PERMILLE:
+        CHECK_NULL(seen, unit, status);
+            macros.unit = stem_to_object::unit(stem);
+            return STATE_NULL;
+
+        case STEM_PRECISION_INTEGER:
+        case STEM_PRECISION_UNLIMITED:
+        case STEM_PRECISION_CURRENCY_STANDARD:
+        case STEM_PRECISION_CURRENCY_CASH:
+        CHECK_NULL(seen, precision, status);
+            macros.precision = stem_to_object::precision(stem);
+            switch (stem) {
+                case STEM_PRECISION_INTEGER:
+                    return STATE_FRACTION_PRECISION; // allows for "precision-integer/@##"
+                default:
+                    return STATE_NULL;
+            }
+
+        case STEM_ROUNDING_MODE_CEILING:
+        case STEM_ROUNDING_MODE_FLOOR:
+        case STEM_ROUNDING_MODE_DOWN:
+        case STEM_ROUNDING_MODE_UP:
+        case STEM_ROUNDING_MODE_HALF_EVEN:
+        case STEM_ROUNDING_MODE_HALF_DOWN:
+        case STEM_ROUNDING_MODE_HALF_UP:
+        case STEM_ROUNDING_MODE_UNNECESSARY:
+        CHECK_NULL(seen, roundingMode, status);
+            macros.roundingMode = stem_to_object::roundingMode(stem);
+            return STATE_NULL;
+
+        case STEM_GROUP_OFF:
+        case STEM_GROUP_MIN2:
+        case STEM_GROUP_AUTO:
+        case STEM_GROUP_ON_ALIGNED:
+        case STEM_GROUP_THOUSANDS:
+        CHECK_NULL(seen, grouper, status);
+            macros.grouper = Grouper::forStrategy(stem_to_object::groupingStrategy(stem));
+            return STATE_NULL;
+
+        case STEM_LATIN:
+        CHECK_NULL(seen, symbols, status);
+            macros.symbols.setTo(NumberingSystem::createInstanceByName("latn", status));
+            return STATE_NULL;
+
+        case STEM_UNIT_WIDTH_NARROW:
+        case STEM_UNIT_WIDTH_SHORT:
+        case STEM_UNIT_WIDTH_FULL_NAME:
+        case STEM_UNIT_WIDTH_ISO_CODE:
+        case STEM_UNIT_WIDTH_HIDDEN:
+        CHECK_NULL(seen, unitWidth, status);
+            macros.unitWidth = stem_to_object::unitWidth(stem);
+            return STATE_NULL;
+
+        case STEM_SIGN_AUTO:
+        case STEM_SIGN_ALWAYS:
+        case STEM_SIGN_NEVER:
+        case STEM_SIGN_ACCOUNTING:
+        case STEM_SIGN_ACCOUNTING_ALWAYS:
+        case STEM_SIGN_EXCEPT_ZERO:
+        case STEM_SIGN_ACCOUNTING_EXCEPT_ZERO:
+        CHECK_NULL(seen, sign, status);
+            macros.sign = stem_to_object::signDisplay(stem);
+            return STATE_NULL;
+
+        case STEM_DECIMAL_AUTO:
+        case STEM_DECIMAL_ALWAYS:
+        CHECK_NULL(seen, decimal, status);
+            macros.decimal = stem_to_object::decimalSeparatorDisplay(stem);
+            return STATE_NULL;
+
+            // Stems requiring an option:
+
+        case STEM_PRECISION_INCREMENT:
+        CHECK_NULL(seen, precision, status);
+            return STATE_INCREMENT_PRECISION;
+
+        case STEM_MEASURE_UNIT:
+        CHECK_NULL(seen, unit, status);
+            return STATE_MEASURE_UNIT;
+
+        case STEM_PER_MEASURE_UNIT:
+        CHECK_NULL(seen, perUnit, status);
+            return STATE_PER_MEASURE_UNIT;
+
+        case STEM_CURRENCY:
+        CHECK_NULL(seen, unit, status);
+            return STATE_CURRENCY_UNIT;
+
+        case STEM_INTEGER_WIDTH:
+        CHECK_NULL(seen, integerWidth, status);
+            return STATE_INTEGER_WIDTH;
+
+        case STEM_NUMBERING_SYSTEM:
+        CHECK_NULL(seen, symbols, status);
+            return STATE_NUMBERING_SYSTEM;
+
+        case STEM_SCALE:
+        CHECK_NULL(seen, scale, status);
+            return STATE_SCALE;
+
+        default:
+            U_ASSERT(false);
+            return STATE_NULL; // return a value: silence compiler warning
+    }
+}
+
+ParseState skeleton::parseOption(ParseState stem, const StringSegment& segment, MacroProps& macros,
+                                 UErrorCode& status) {
+
+    ///// Required options: /////
+
+    switch (stem) {
+        case STATE_CURRENCY_UNIT:
+            blueprint_helpers::parseCurrencyOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_MEASURE_UNIT:
+            blueprint_helpers::parseMeasureUnitOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_PER_MEASURE_UNIT:
+            blueprint_helpers::parseMeasurePerUnitOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_INCREMENT_PRECISION:
+            blueprint_helpers::parseIncrementOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_INTEGER_WIDTH:
+            blueprint_helpers::parseIntegerWidthOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_NUMBERING_SYSTEM:
+            blueprint_helpers::parseNumberingSystemOption(segment, macros, status);
+            return STATE_NULL;
+        case STATE_SCALE:
+            blueprint_helpers::parseScaleOption(segment, macros, status);
+            return STATE_NULL;
+        default:
+            break;
+    }
+
+    ///// Non-required options: /////
+
+    // Scientific options
+    switch (stem) {
+        case STATE_SCIENTIFIC:
+            if (blueprint_helpers::parseExponentWidthOption(segment, macros, status)) {
+                return STATE_SCIENTIFIC;
+            }
+            if (U_FAILURE(status)) {
+                return {};
+            }
+            if (blueprint_helpers::parseExponentSignOption(segment, macros, status)) {
+                return STATE_SCIENTIFIC;
+            }
+            if (U_FAILURE(status)) {
+                return {};
+            }
+            break;
+        default:
+            break;
+    }
+
+    // Frac-sig option
+    switch (stem) {
+        case STATE_FRACTION_PRECISION:
+            if (blueprint_helpers::parseFracSigOption(segment, macros, status)) {
+                return STATE_NULL;
+            }
+            if (U_FAILURE(status)) {
+                return {};
+            }
+            break;
+        default:
+            break;
+    }
+
+    // Unknown option
+    // throw new SkeletonSyntaxException("Invalid option", segment);
+    status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+    return STATE_NULL;
+}
+
+void GeneratorHelpers::generateSkeleton(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (U_FAILURE(status)) { return; }
+
+    // Supported options
+    if (GeneratorHelpers::notation(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::unit(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::perUnit(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::precision(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::roundingMode(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::grouping(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::integerWidth(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::symbols(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::unitWidth(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::sign(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::decimal(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+    if (GeneratorHelpers::scale(macros, sb, status)) {
+        sb.append(u' ');
+    }
+    if (U_FAILURE(status)) { return; }
+
+    // Unsupported options
+    if (!macros.padder.isBogus()) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+    if (macros.affixProvider != nullptr) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+    if (macros.rules != nullptr) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+    if (macros.currencySymbols != nullptr) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+    // Remove the trailing space
+    if (sb.length() > 0) {
+        sb.truncate(sb.length() - 1);
+    }
+}
+
+
+bool blueprint_helpers::parseExponentWidthOption(const StringSegment& segment, MacroProps& macros,
+                                                 UErrorCode&) {
+    if (segment.charAt(0) != u'+') {
+        return false;
+    }
+    int32_t offset = 1;
+    int32_t minExp = 0;
+    for (; offset < segment.length(); offset++) {
+        if (segment.charAt(offset) == u'e') {
+            minExp++;
+        } else {
+            break;
+        }
+    }
+    if (offset < segment.length()) {
+        return false;
+    }
+    // Use the public APIs to enforce bounds checking
+    macros.notation = static_cast<ScientificNotation&>(macros.notation).withMinExponentDigits(minExp);
+    return true;
+}
+
+void
+blueprint_helpers::generateExponentWidthOption(int32_t minExponentDigits, UnicodeString& sb, UErrorCode&) {
+    sb.append(u'+');
+    appendMultiple(sb, u'e', minExponentDigits);
+}
+
+bool
+blueprint_helpers::parseExponentSignOption(const StringSegment& segment, MacroProps& macros, UErrorCode&) {
+    // Get the sign display type out of the CharsTrie data structure.
+    UCharsTrie tempStemTrie(kSerializedStemTrie);
+    UStringTrieResult result = tempStemTrie.next(
+            segment.toTempUnicodeString().getBuffer(),
+            segment.length());
+    if (result != USTRINGTRIE_INTERMEDIATE_VALUE && result != USTRINGTRIE_FINAL_VALUE) {
+        return false;
+    }
+    auto sign = stem_to_object::signDisplay(static_cast<StemEnum>(tempStemTrie.getValue()));
+    if (sign == UNUM_SIGN_COUNT) {
+        return false;
+    }
+    macros.notation = static_cast<ScientificNotation&>(macros.notation).withExponentSignDisplay(sign);
+    return true;
+}
+
+void blueprint_helpers::parseCurrencyOption(const StringSegment& segment, MacroProps& macros,
+                                            UErrorCode& status) {
+    // Unlike ICU4J, have to check length manually because ICU4C CurrencyUnit does not check it for us
+    if (segment.length() != 3) {
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    const UChar* currencyCode = segment.toTempUnicodeString().getBuffer();
+    UErrorCode localStatus = U_ZERO_ERROR;
+    CurrencyUnit currency(currencyCode, localStatus);
+    if (U_FAILURE(localStatus)) {
+        // Not 3 ascii chars
+        // throw new SkeletonSyntaxException("Invalid currency", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    // Slicing is OK
+    macros.unit = currency; // NOLINT
+}
+
+void
+blueprint_helpers::generateCurrencyOption(const CurrencyUnit& currency, UnicodeString& sb, UErrorCode&) {
+    sb.append(currency.getISOCurrency(), -1);
+}
+
+void blueprint_helpers::parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros,
+                                               UErrorCode& status) {
+    const UnicodeString stemString = segment.toTempUnicodeString();
+
+    // NOTE: The category (type) of the unit is guaranteed to be a valid subtag (alphanumeric)
+    // http://unicode.org/reports/tr35/#Validity_Data
+    int firstHyphen = 0;
+    while (firstHyphen < stemString.length() && stemString.charAt(firstHyphen) != '-') {
+        firstHyphen++;
+    }
+    if (firstHyphen == stemString.length()) {
+        // throw new SkeletonSyntaxException("Invalid measure unit option", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString type;
+    SKELETON_UCHAR_TO_CHAR(type, stemString, 0, firstHyphen, status);
+    CharString subType;
+    SKELETON_UCHAR_TO_CHAR(subType, stemString, firstHyphen + 1, stemString.length(), status);
+
+    // Note: the largest type as of this writing (March 2018) is "volume", which has 24 units.
+    static constexpr int32_t CAPACITY = 30;
+    MeasureUnit units[CAPACITY];
+    UErrorCode localStatus = U_ZERO_ERROR;
+    int32_t numUnits = MeasureUnit::getAvailable(type.data(), units, CAPACITY, localStatus);
+    if (U_FAILURE(localStatus)) {
+        // More than 30 units in this type?
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return;
+    }
+    for (int32_t i = 0; i < numUnits; i++) {
+        auto& unit = units[i];
+        if (uprv_strcmp(subType.data(), unit.getSubtype()) == 0) {
+            macros.unit = unit;
+            return;
+        }
+    }
+
+    // throw new SkeletonSyntaxException("Unknown measure unit", segment);
+    status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+}
+
+void blueprint_helpers::generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb,
+                                                  UErrorCode&) {
+    // Need to do char <-> UChar conversion...
+    sb.append(UnicodeString(measureUnit.getType(), -1, US_INV));
+    sb.append(u'-');
+    sb.append(UnicodeString(measureUnit.getSubtype(), -1, US_INV));
+}
+
+void blueprint_helpers::parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros,
+                                                  UErrorCode& status) {
+    // A little bit of a hack: safe the current unit (numerator), call the main measure unit
+    // parsing code, put back the numerator unit, and put the new unit into per-unit.
+    MeasureUnit numerator = macros.unit;
+    parseMeasureUnitOption(segment, macros, status);
+    if (U_FAILURE(status)) { return; }
+    macros.perUnit = macros.unit;
+    macros.unit = numerator;
+}
+
+void blueprint_helpers::parseFractionStem(const StringSegment& segment, MacroProps& macros,
+                                          UErrorCode& status) {
+    U_ASSERT(segment.charAt(0) == u'.');
+    int32_t offset = 1;
+    int32_t minFrac = 0;
+    int32_t maxFrac;
+    for (; offset < segment.length(); offset++) {
+        if (segment.charAt(offset) == u'0') {
+            minFrac++;
+        } else {
+            break;
+        }
+    }
+    if (offset < segment.length()) {
+        if (segment.charAt(offset) == u'+') {
+            maxFrac = -1;
+            offset++;
+        } else {
+            maxFrac = minFrac;
+            for (; offset < segment.length(); offset++) {
+                if (segment.charAt(offset) == u'#') {
+                    maxFrac++;
+                } else {
+                    break;
+                }
+            }
+        }
+    } else {
+        maxFrac = minFrac;
+    }
+    if (offset < segment.length()) {
+        // throw new SkeletonSyntaxException("Invalid fraction stem", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    // Use the public APIs to enforce bounds checking
+    if (maxFrac == -1) {
+        macros.precision = Precision::minFraction(minFrac);
+    } else {
+        macros.precision = Precision::minMaxFraction(minFrac, maxFrac);
+    }
+}
+
+void
+blueprint_helpers::generateFractionStem(int32_t minFrac, int32_t maxFrac, UnicodeString& sb, UErrorCode&) {
+    if (minFrac == 0 && maxFrac == 0) {
+        sb.append(u"precision-integer", -1);
+        return;
+    }
+    sb.append(u'.');
+    appendMultiple(sb, u'0', minFrac);
+    if (maxFrac == -1) {
+        sb.append(u'+');
+    } else {
+        appendMultiple(sb, u'#', maxFrac - minFrac);
+    }
+}
+
+void
+blueprint_helpers::parseDigitsStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status) {
+    U_ASSERT(segment.charAt(0) == u'@');
+    int offset = 0;
+    int minSig = 0;
+    int maxSig;
+    for (; offset < segment.length(); offset++) {
+        if (segment.charAt(offset) == u'@') {
+            minSig++;
+        } else {
+            break;
+        }
+    }
+    if (offset < segment.length()) {
+        if (segment.charAt(offset) == u'+') {
+            maxSig = -1;
+            offset++;
+        } else {
+            maxSig = minSig;
+            for (; offset < segment.length(); offset++) {
+                if (segment.charAt(offset) == u'#') {
+                    maxSig++;
+                } else {
+                    break;
+                }
+            }
+        }
+    } else {
+        maxSig = minSig;
+    }
+    if (offset < segment.length()) {
+        // throw new SkeletonSyntaxException("Invalid significant digits stem", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    // Use the public APIs to enforce bounds checking
+    if (maxSig == -1) {
+        macros.precision = Precision::minSignificantDigits(minSig);
+    } else {
+        macros.precision = Precision::minMaxSignificantDigits(minSig, maxSig);
+    }
+}
+
+void
+blueprint_helpers::generateDigitsStem(int32_t minSig, int32_t maxSig, UnicodeString& sb, UErrorCode&) {
+    appendMultiple(sb, u'@', minSig);
+    if (maxSig == -1) {
+        sb.append(u'+');
+    } else {
+        appendMultiple(sb, u'#', maxSig - minSig);
+    }
+}
+
+bool blueprint_helpers::parseFracSigOption(const StringSegment& segment, MacroProps& macros,
+                                           UErrorCode& status) {
+    if (segment.charAt(0) != u'@') {
+        return false;
+    }
+    int offset = 0;
+    int minSig = 0;
+    int maxSig;
+    for (; offset < segment.length(); offset++) {
+        if (segment.charAt(offset) == u'@') {
+            minSig++;
+        } else {
+            break;
+        }
+    }
+    // For the frac-sig option, there must be minSig or maxSig but not both.
+    // Valid: @+, @@+, @@@+
+    // Valid: @#, @##, @###
+    // Invalid: @, @@, @@@
+    // Invalid: @@#, @@##, @@@#
+    if (offset < segment.length()) {
+        if (segment.charAt(offset) == u'+') {
+            maxSig = -1;
+            offset++;
+        } else if (minSig > 1) {
+            // @@#, @@##, @@@#
+            // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
+            status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+            return false;
+        } else {
+            maxSig = minSig;
+            for (; offset < segment.length(); offset++) {
+                if (segment.charAt(offset) == u'#') {
+                    maxSig++;
+                } else {
+                    break;
+                }
+            }
+        }
+    } else {
+        // @, @@, @@@
+        // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return false;
+    }
+    if (offset < segment.length()) {
+        // throw new SkeletonSyntaxException("Invalid digits option for fraction rounder", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return false;
+    }
+
+    auto& oldPrecision = static_cast<const FractionPrecision&>(macros.precision);
+    if (maxSig == -1) {
+        macros.precision = oldPrecision.withMinDigits(minSig);
+    } else {
+        macros.precision = oldPrecision.withMaxDigits(maxSig);
+    }
+    return true;
+}
+
+void blueprint_helpers::parseIncrementOption(const StringSegment& segment, MacroProps& macros,
+                                             UErrorCode& status) {
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString buffer;
+    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
+
+    // Utilize DecimalQuantity/decNumber to parse this for us.
+    DecimalQuantity dq;
+    UErrorCode localStatus = U_ZERO_ERROR;
+    dq.setToDecNumber({buffer.data(), buffer.length()}, localStatus);
+    if (U_FAILURE(localStatus)) {
+        // throw new SkeletonSyntaxException("Invalid rounding increment", segment, e);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    double increment = dq.toDouble();
+
+    // We also need to figure out how many digits. Do a brute force string operation.
+    int decimalOffset = 0;
+    while (decimalOffset < segment.length() && segment.charAt(decimalOffset) != '.') {
+        decimalOffset++;
+    }
+    if (decimalOffset == segment.length()) {
+        macros.precision = Precision::increment(increment);
+    } else {
+        int32_t fractionLength = segment.length() - decimalOffset - 1;
+        macros.precision = Precision::increment(increment).withMinFraction(fractionLength);
+    }
+}
+
+void blueprint_helpers::generateIncrementOption(double increment, int32_t trailingZeros, UnicodeString& sb,
+                                                UErrorCode&) {
+    // Utilize DecimalQuantity/double_conversion to format this for us.
+    DecimalQuantity dq;
+    dq.setToDouble(increment);
+    dq.roundToInfinity();
+    sb.append(dq.toPlainString());
+
+    // We might need to append extra trailing zeros for min fraction...
+    if (trailingZeros > 0) {
+        appendMultiple(sb, u'0', trailingZeros);
+    }
+}
+
+void blueprint_helpers::parseIntegerWidthOption(const StringSegment& segment, MacroProps& macros,
+                                                UErrorCode& status) {
+    int32_t offset = 0;
+    int32_t minInt = 0;
+    int32_t maxInt;
+    if (segment.charAt(0) == u'+') {
+        maxInt = -1;
+        offset++;
+    } else {
+        maxInt = 0;
+    }
+    for (; offset < segment.length(); offset++) {
+        if (segment.charAt(offset) == u'#') {
+            maxInt++;
+        } else {
+            break;
+        }
+    }
+    if (offset < segment.length()) {
+        for (; offset < segment.length(); offset++) {
+            if (segment.charAt(offset) == u'0') {
+                minInt++;
+            } else {
+                break;
+            }
+        }
+    }
+    if (maxInt != -1) {
+        maxInt += minInt;
+    }
+    if (offset < segment.length()) {
+        // throw new SkeletonSyntaxException("Invalid integer width stem", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    // Use the public APIs to enforce bounds checking
+    if (maxInt == -1) {
+        macros.integerWidth = IntegerWidth::zeroFillTo(minInt);
+    } else {
+        macros.integerWidth = IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt);
+    }
+}
+
+void blueprint_helpers::generateIntegerWidthOption(int32_t minInt, int32_t maxInt, UnicodeString& sb,
+                                                   UErrorCode&) {
+    if (maxInt == -1) {
+        sb.append(u'+');
+    } else {
+        appendMultiple(sb, u'#', maxInt - minInt);
+    }
+    appendMultiple(sb, u'0', minInt);
+}
+
+void blueprint_helpers::parseNumberingSystemOption(const StringSegment& segment, MacroProps& macros,
+                                                   UErrorCode& status) {
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString buffer;
+    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
+
+    NumberingSystem* ns = NumberingSystem::createInstanceByName(buffer.data(), status);
+    if (ns == nullptr || U_FAILURE(status)) {
+        // This is a skeleton syntax error; don't bubble up the low-level NumberingSystem error
+        // throw new SkeletonSyntaxException("Unknown numbering system", segment);
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+    macros.symbols.setTo(ns);
+}
+
+void blueprint_helpers::generateNumberingSystemOption(const NumberingSystem& ns, UnicodeString& sb,
+                                                      UErrorCode&) {
+    // Need to do char <-> UChar conversion...
+    sb.append(UnicodeString(ns.getName(), -1, US_INV));
+}
+
+void blueprint_helpers::parseScaleOption(const StringSegment& segment, MacroProps& macros,
+                                              UErrorCode& status) {
+    // Need to do char <-> UChar conversion...
+    U_ASSERT(U_SUCCESS(status));
+    CharString buffer;
+    SKELETON_UCHAR_TO_CHAR(buffer, segment.toTempUnicodeString(), 0, segment.length(), status);
+
+    LocalPointer<DecNum> decnum(new DecNum(), status);
+    if (U_FAILURE(status)) { return; }
+    decnum->setTo({buffer.data(), buffer.length()}, status);
+    if (U_FAILURE(status)) {
+        // This is a skeleton syntax error; don't let the low-level decnum error bubble up
+        status = U_NUMBER_SKELETON_SYNTAX_ERROR;
+        return;
+    }
+
+    // NOTE: The constructor will optimize the decnum for us if possible.
+    macros.scale = {0, decnum.orphan()};
+}
+
+void blueprint_helpers::generateScaleOption(int32_t magnitude, const DecNum* arbitrary, UnicodeString& sb,
+                                            UErrorCode& status) {
+    // Utilize DecimalQuantity/double_conversion to format this for us.
+    DecimalQuantity dq;
+    if (arbitrary != nullptr) {
+        dq.setToDecNum(*arbitrary, status);
+        if (U_FAILURE(status)) { return; }
+    } else {
+        dq.setToInt(1);
+    }
+    dq.adjustMagnitude(magnitude);
+    dq.roundToInfinity();
+    sb.append(dq.toPlainString());
+}
+
+
+bool GeneratorHelpers::notation(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (macros.notation.fType == Notation::NTN_COMPACT) {
+        UNumberCompactStyle style = macros.notation.fUnion.compactStyle;
+        if (style == UNumberCompactStyle::UNUM_LONG) {
+            sb.append(u"compact-long", -1);
+            return true;
+        } else if (style == UNumberCompactStyle::UNUM_SHORT) {
+            sb.append(u"compact-short", -1);
+            return true;
+        } else {
+            // Compact notation generated from custom data (not supported in skeleton)
+            // The other compact notations are literals
+            status = U_UNSUPPORTED_ERROR;
+            return false;
+        }
+    } else if (macros.notation.fType == Notation::NTN_SCIENTIFIC) {
+        const Notation::ScientificSettings& impl = macros.notation.fUnion.scientific;
+        if (impl.fEngineeringInterval == 3) {
+            sb.append(u"engineering", -1);
+        } else {
+            sb.append(u"scientific", -1);
+        }
+        if (impl.fMinExponentDigits > 1) {
+            sb.append(u'/');
+            blueprint_helpers::generateExponentWidthOption(impl.fMinExponentDigits, sb, status);
+            if (U_FAILURE(status)) {
+                return false;
+            }
+        }
+        if (impl.fExponentSignDisplay != UNUM_SIGN_AUTO) {
+            sb.append(u'/');
+            enum_to_stem_string::signDisplay(impl.fExponentSignDisplay, sb);
+        }
+        return true;
+    } else {
+        // Default value is not shown in normalized form
+        return false;
+    }
+}
+
+bool GeneratorHelpers::unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (utils::unitIsCurrency(macros.unit)) {
+        sb.append(u"currency/", -1);
+        CurrencyUnit currency(macros.unit, status);
+        if (U_FAILURE(status)) {
+            return false;
+        }
+        blueprint_helpers::generateCurrencyOption(currency, sb, status);
+        return true;
+    } else if (utils::unitIsNoUnit(macros.unit)) {
+        if (utils::unitIsPercent(macros.unit)) {
+            sb.append(u"percent", -1);
+            return true;
+        } else if (utils::unitIsPermille(macros.unit)) {
+            sb.append(u"permille", -1);
+            return true;
+        } else {
+            // Default value is not shown in normalized form
+            return false;
+        }
+    } else {
+        sb.append(u"measure-unit/", -1);
+        blueprint_helpers::generateMeasureUnitOption(macros.unit, sb, status);
+        return true;
+    }
+}
+
+bool GeneratorHelpers::perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    // Per-units are currently expected to be only MeasureUnits.
+    if (utils::unitIsNoUnit(macros.perUnit)) {
+        if (utils::unitIsPercent(macros.perUnit) || utils::unitIsPermille(macros.perUnit)) {
+            status = U_UNSUPPORTED_ERROR;
+            return false;
+        } else {
+            // Default value: ok to ignore
+            return false;
+        }
+    } else if (utils::unitIsCurrency(macros.perUnit)) {
+        status = U_UNSUPPORTED_ERROR;
+        return false;
+    } else {
+        sb.append(u"per-measure-unit/", -1);
+        blueprint_helpers::generateMeasureUnitOption(macros.perUnit, sb, status);
+        return true;
+    }
+}
+
+bool GeneratorHelpers::precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (macros.precision.fType == Precision::RND_NONE) {
+        sb.append(u"precision-unlimited", -1);
+    } else if (macros.precision.fType == Precision::RND_FRACTION) {
+        const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig;
+        blueprint_helpers::generateFractionStem(impl.fMinFrac, impl.fMaxFrac, sb, status);
+    } else if (macros.precision.fType == Precision::RND_SIGNIFICANT) {
+        const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig;
+        blueprint_helpers::generateDigitsStem(impl.fMinSig, impl.fMaxSig, sb, status);
+    } else if (macros.precision.fType == Precision::RND_FRACTION_SIGNIFICANT) {
+        const Precision::FractionSignificantSettings& impl = macros.precision.fUnion.fracSig;
+        blueprint_helpers::generateFractionStem(impl.fMinFrac, impl.fMaxFrac, sb, status);
+        sb.append(u'/');
+        if (impl.fMinSig == -1) {
+            blueprint_helpers::generateDigitsStem(1, impl.fMaxSig, sb, status);
+        } else {
+            blueprint_helpers::generateDigitsStem(impl.fMinSig, -1, sb, status);
+        }
+    } else if (macros.precision.fType == Precision::RND_INCREMENT) {
+        const Precision::IncrementSettings& impl = macros.precision.fUnion.increment;
+        sb.append(u"precision-increment/", -1);
+        blueprint_helpers::generateIncrementOption(
+                impl.fIncrement,
+                impl.fMinFrac - impl.fMaxFrac,
+                sb,
+                status);
+    } else if (macros.precision.fType == Precision::RND_CURRENCY) {
+        UCurrencyUsage usage = macros.precision.fUnion.currencyUsage;
+        if (usage == UCURR_USAGE_STANDARD) {
+            sb.append(u"precision-currency-standard", -1);
+        } else {
+            sb.append(u"precision-currency-cash", -1);
+        }
+    } else {
+        // Bogus or Error
+        return false;
+    }
+
+    // NOTE: Always return true for rounding because the default value depends on other options.
+    return true;
+}
+
+bool GeneratorHelpers::roundingMode(const MacroProps& macros, UnicodeString& sb, UErrorCode&) {
+    if (macros.roundingMode == kDefaultMode) {
+        return false; // Default
+    }
+    enum_to_stem_string::roundingMode(macros.roundingMode, sb);
+    return true;
+}
+
+bool GeneratorHelpers::grouping(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (macros.grouper.isBogus()) {
+        return false; // No value
+    } else if (macros.grouper.fStrategy == UNUM_GROUPING_COUNT) {
+        status = U_UNSUPPORTED_ERROR;
+        return false;
+    } else if (macros.grouper.fStrategy == UNUM_GROUPING_AUTO) {
+        return false; // Default value
+    } else {
+        enum_to_stem_string::groupingStrategy(macros.grouper.fStrategy, sb);
+        return true;
+    }
+}
+
+bool GeneratorHelpers::integerWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (macros.integerWidth.fHasError || macros.integerWidth.isBogus() ||
+        macros.integerWidth == IntegerWidth::standard()) {
+        // Error or Default
+        return false;
+    }
+    sb.append(u"integer-width/", -1);
+    blueprint_helpers::generateIntegerWidthOption(
+            macros.integerWidth.fUnion.minMaxInt.fMinInt,
+            macros.integerWidth.fUnion.minMaxInt.fMaxInt,
+            sb,
+            status);
+    return true;
+}
+
+bool GeneratorHelpers::symbols(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (macros.symbols.isNumberingSystem()) {
+        const NumberingSystem& ns = *macros.symbols.getNumberingSystem();
+        if (uprv_strcmp(ns.getName(), "latn") == 0) {
+            sb.append(u"latin", -1);
+        } else {
+            sb.append(u"numbering-system/", -1);
+            blueprint_helpers::generateNumberingSystemOption(ns, sb, status);
+        }
+        return true;
+    } else if (macros.symbols.isDecimalFormatSymbols()) {
+        status = U_UNSUPPORTED_ERROR;
+        return false;
+    } else {
+        // No custom symbols
+        return false;
+    }
+}
+
+bool GeneratorHelpers::unitWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode&) {
+    if (macros.unitWidth == UNUM_UNIT_WIDTH_SHORT || macros.unitWidth == UNUM_UNIT_WIDTH_COUNT) {
+        return false; // Default or Bogus
+    }
+    enum_to_stem_string::unitWidth(macros.unitWidth, sb);
+    return true;
+}
+
+bool GeneratorHelpers::sign(const MacroProps& macros, UnicodeString& sb, UErrorCode&) {
+    if (macros.sign == UNUM_SIGN_AUTO || macros.sign == UNUM_SIGN_COUNT) {
+        return false; // Default or Bogus
+    }
+    enum_to_stem_string::signDisplay(macros.sign, sb);
+    return true;
+}
+
+bool GeneratorHelpers::decimal(const MacroProps& macros, UnicodeString& sb, UErrorCode&) {
+    if (macros.decimal == UNUM_DECIMAL_SEPARATOR_AUTO || macros.decimal == UNUM_DECIMAL_SEPARATOR_COUNT) {
+        return false; // Default or Bogus
+    }
+    enum_to_stem_string::decimalSeparatorDisplay(macros.decimal, sb);
+    return true;
+}
+
+bool GeneratorHelpers::scale(const MacroProps& macros, UnicodeString& sb, UErrorCode& status) {
+    if (!macros.scale.isValid()) {
+        return false; // Default or Bogus
+    }
+    sb.append(u"scale/", -1);
+    blueprint_helpers::generateScaleOption(
+            macros.scale.fMagnitude,
+            macros.scale.fArbitrary,
+            sb,
+            status);
+    return true;
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_skeletons.h b/deps/icu-small/source/i18n/number_skeletons.h
new file mode 100644
index 00000000000000..0161f5f0ba8c1a
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_skeletons.h
@@ -0,0 +1,327 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMBER_SKELETONS_H__
+#define __SOURCE_NUMBER_SKELETONS_H__
+
+#include "number_types.h"
+#include "numparse_types.h"
+#include "unicode/ucharstrie.h"
+
+using icu::numparse::impl::StringSegment;
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+// Forward-declaration
+struct SeenMacroProps;
+
+// namespace for enums and entrypoint functions
+namespace skeleton {
+
+///////////////////////////////////////////////////////////////////////////////////////
+// NOTE: For an example of how to add a new stem to the number skeleton parser, see: //
+// http://bugs.icu-project.org/trac/changeset/41193                                  //
+///////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * While parsing a skeleton, this enum records what type of option we expect to find next.
+ */
+enum ParseState {
+
+    // Section 0: We expect whitespace or a stem, but not an option:
+
+    STATE_NULL,
+
+    // Section 1: We might accept an option, but it is not required:
+
+    STATE_SCIENTIFIC,
+    STATE_FRACTION_PRECISION,
+
+    // Section 2: An option is required:
+
+    STATE_INCREMENT_PRECISION,
+    STATE_MEASURE_UNIT,
+    STATE_PER_MEASURE_UNIT,
+    STATE_CURRENCY_UNIT,
+    STATE_INTEGER_WIDTH,
+    STATE_NUMBERING_SYSTEM,
+    STATE_SCALE,
+};
+
+/**
+ * All possible stem literals have an entry in the StemEnum. The enum name is the kebab case stem
+ * string literal written in upper snake case.
+ *
+ * @see StemToObject
+ * @see #SERIALIZED_STEM_TRIE
+ */
+enum StemEnum {
+
+    // Section 1: Stems that do not require an option:
+
+    STEM_COMPACT_SHORT,
+    STEM_COMPACT_LONG,
+    STEM_SCIENTIFIC,
+    STEM_ENGINEERING,
+    STEM_NOTATION_SIMPLE,
+    STEM_BASE_UNIT,
+    STEM_PERCENT,
+    STEM_PERMILLE,
+    STEM_PRECISION_INTEGER,
+    STEM_PRECISION_UNLIMITED,
+    STEM_PRECISION_CURRENCY_STANDARD,
+    STEM_PRECISION_CURRENCY_CASH,
+    STEM_ROUNDING_MODE_CEILING,
+    STEM_ROUNDING_MODE_FLOOR,
+    STEM_ROUNDING_MODE_DOWN,
+    STEM_ROUNDING_MODE_UP,
+    STEM_ROUNDING_MODE_HALF_EVEN,
+    STEM_ROUNDING_MODE_HALF_DOWN,
+    STEM_ROUNDING_MODE_HALF_UP,
+    STEM_ROUNDING_MODE_UNNECESSARY,
+    STEM_GROUP_OFF,
+    STEM_GROUP_MIN2,
+    STEM_GROUP_AUTO,
+    STEM_GROUP_ON_ALIGNED,
+    STEM_GROUP_THOUSANDS,
+    STEM_LATIN,
+    STEM_UNIT_WIDTH_NARROW,
+    STEM_UNIT_WIDTH_SHORT,
+    STEM_UNIT_WIDTH_FULL_NAME,
+    STEM_UNIT_WIDTH_ISO_CODE,
+    STEM_UNIT_WIDTH_HIDDEN,
+    STEM_SIGN_AUTO,
+    STEM_SIGN_ALWAYS,
+    STEM_SIGN_NEVER,
+    STEM_SIGN_ACCOUNTING,
+    STEM_SIGN_ACCOUNTING_ALWAYS,
+    STEM_SIGN_EXCEPT_ZERO,
+    STEM_SIGN_ACCOUNTING_EXCEPT_ZERO,
+    STEM_DECIMAL_AUTO,
+    STEM_DECIMAL_ALWAYS,
+
+    // Section 2: Stems that DO require an option:
+
+    STEM_PRECISION_INCREMENT,
+    STEM_MEASURE_UNIT,
+    STEM_PER_MEASURE_UNIT,
+    STEM_CURRENCY,
+    STEM_INTEGER_WIDTH,
+    STEM_NUMBERING_SYSTEM,
+    STEM_SCALE,
+};
+
+/**
+ * Creates a NumberFormatter corresponding to the given skeleton string.
+ *
+ * @param skeletonString
+ *            A number skeleton string, possibly not in its shortest form.
+ * @return An UnlocalizedNumberFormatter with behavior defined by the given skeleton string.
+ */
+UnlocalizedNumberFormatter create(const UnicodeString& skeletonString, UErrorCode& status);
+
+/**
+ * Create a skeleton string corresponding to the given NumberFormatter.
+ *
+ * @param macros
+ *            The NumberFormatter options object.
+ * @return A skeleton string in normalized form.
+ */
+UnicodeString generate(const MacroProps& macros, UErrorCode& status);
+
+/**
+ * Converts from a skeleton string to a MacroProps. This method contains the primary parse loop.
+ *
+ * Internal: use the create() endpoint instead of this function.
+ */
+MacroProps parseSkeleton(const UnicodeString& skeletonString, UErrorCode& status);
+
+/**
+ * Given that the current segment represents a stem, parse it and save the result.
+ *
+ * @return The next state after parsing this stem, corresponding to what subset of options to expect.
+ */
+ParseState parseStem(const StringSegment& segment, const UCharsTrie& stemTrie, SeenMacroProps& seen,
+                     MacroProps& macros, UErrorCode& status);
+
+/**
+ * Given that the current segment represents an option, parse it and save the result.
+ *
+ * @return The next state after parsing this option, corresponding to what subset of options to
+ *         expect next.
+ */
+ParseState
+parseOption(ParseState stem, const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+} // namespace skeleton
+
+
+/**
+ * Namespace for utility methods that convert from StemEnum to corresponding objects or enums. This
+ * applies to only the "Section 1" stems, those that are well-defined without an option.
+ */
+namespace stem_to_object {
+
+Notation notation(skeleton::StemEnum stem);
+
+MeasureUnit unit(skeleton::StemEnum stem);
+
+Precision precision(skeleton::StemEnum stem);
+
+UNumberFormatRoundingMode roundingMode(skeleton::StemEnum stem);
+
+UGroupingStrategy groupingStrategy(skeleton::StemEnum stem);
+
+UNumberUnitWidth unitWidth(skeleton::StemEnum stem);
+
+UNumberSignDisplay signDisplay(skeleton::StemEnum stem);
+
+UNumberDecimalSeparatorDisplay decimalSeparatorDisplay(skeleton::StemEnum stem);
+
+} // namespace stem_to_object
+
+/**
+ * Namespace for utility methods that convert from enums to stem strings. More complex object conversions
+ * take place in the object_to_stem_string namespace.
+ */
+namespace enum_to_stem_string {
+
+void roundingMode(UNumberFormatRoundingMode value, UnicodeString& sb);
+
+void groupingStrategy(UGroupingStrategy value, UnicodeString& sb);
+
+void unitWidth(UNumberUnitWidth value, UnicodeString& sb);
+
+void signDisplay(UNumberSignDisplay value, UnicodeString& sb);
+
+void decimalSeparatorDisplay(UNumberDecimalSeparatorDisplay value, UnicodeString& sb);
+
+} // namespace enum_to_stem_string
+
+/**
+ * Namespace for utility methods for processing stems and options that cannot be interpreted literally.
+ */
+namespace blueprint_helpers {
+
+/** @return Whether we successfully found and parsed an exponent width option. */
+bool parseExponentWidthOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateExponentWidthOption(int32_t minExponentDigits, UnicodeString& sb, UErrorCode& status);
+
+/** @return Whether we successfully found and parsed an exponent sign option. */
+bool parseExponentSignOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void parseCurrencyOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateCurrencyOption(const CurrencyUnit& currency, UnicodeString& sb, UErrorCode& status);
+
+void parseMeasureUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateMeasureUnitOption(const MeasureUnit& measureUnit, UnicodeString& sb, UErrorCode& status);
+
+void parseMeasurePerUnitOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void parseFractionStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateFractionStem(int32_t minFrac, int32_t maxFrac, UnicodeString& sb, UErrorCode& status);
+
+void parseDigitsStem(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateDigitsStem(int32_t minSig, int32_t maxSig, UnicodeString& sb, UErrorCode& status);
+
+/** @return Whether we successfully found and parsed a frac-sig option. */
+bool parseFracSigOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void parseIncrementOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void
+generateIncrementOption(double increment, int32_t trailingZeros, UnicodeString& sb, UErrorCode& status);
+
+void parseIntegerWidthOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateIntegerWidthOption(int32_t minInt, int32_t maxInt, UnicodeString& sb, UErrorCode& status);
+
+void parseNumberingSystemOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateNumberingSystemOption(const NumberingSystem& ns, UnicodeString& sb, UErrorCode& status);
+
+void parseScaleOption(const StringSegment& segment, MacroProps& macros, UErrorCode& status);
+
+void generateScaleOption(int32_t magnitude, const DecNum* arbitrary, UnicodeString& sb,
+                              UErrorCode& status);
+
+} // namespace blueprint_helpers
+
+/**
+ * Class for utility methods for generating a token corresponding to each macro-prop. Each method
+ * returns whether or not a token was written to the string builder.
+ *
+ * This needs to be a class, not a namespace, so it can be friended.
+ */
+class GeneratorHelpers {
+  public:
+    /**
+     * Main skeleton generator function. Appends the normalized skeleton for the MacroProps to the given
+     * StringBuilder.
+     *
+     * Internal: use the create() endpoint instead of this function.
+     */
+    static void generateSkeleton(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+  private:
+    static bool notation(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool unit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool perUnit(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool precision(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool roundingMode(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool grouping(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool integerWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool symbols(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool unitWidth(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool sign(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool decimal(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+    static bool scale(const MacroProps& macros, UnicodeString& sb, UErrorCode& status);
+
+};
+
+/**
+ * Struct for null-checking.
+ * In Java, we can just check the object reference. In C++, we need a different method.
+ */
+struct SeenMacroProps {
+    bool notation = false;
+    bool unit = false;
+    bool perUnit = false;
+    bool precision = false;
+    bool roundingMode = false;
+    bool grouper = false;
+    bool padder = false;
+    bool integerWidth = false;
+    bool symbols = false;
+    bool unitWidth = false;
+    bool sign = false;
+    bool decimal = false;
+    bool scale = false;
+};
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMBER_SKELETONS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_stringbuilder.cpp b/deps/icu-small/source/i18n/number_stringbuilder.cpp
index 37159d7e53a60a..37770d11d51dfb 100644
--- a/deps/icu-small/source/i18n/number_stringbuilder.cpp
+++ b/deps/icu-small/source/i18n/number_stringbuilder.cpp
@@ -3,11 +3,10 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 
 #include "number_stringbuilder.h"
 #include "unicode/utf16.h"
-#include "uvectr32.h"
 
 using namespace icu;
 using namespace icu::number;
@@ -337,6 +336,11 @@ UnicodeString NumberStringBuilder::toUnicodeString() const {
     return UnicodeString(getCharPtr() + fZero, fLength);
 }
 
+const UnicodeString NumberStringBuilder::toTempUnicodeString() const {
+    // Readonly-alias constructor:
+    return UnicodeString(FALSE, getCharPtr() + fZero, fLength);
+}
+
 UnicodeString NumberStringBuilder::toDebugString() const {
     UnicodeString sb;
     sb.append(u"<NumberStringBuilder [", -1);
@@ -408,23 +412,24 @@ bool NumberStringBuilder::contentEquals(const NumberStringBuilder &other) const
     return true;
 }
 
-void NumberStringBuilder::populateFieldPosition(FieldPosition &fp, int32_t offset, UErrorCode &status) const {
+bool NumberStringBuilder::nextFieldPosition(FieldPosition& fp, UErrorCode& status) const {
     int32_t rawField = fp.getField();
 
     if (rawField == FieldPosition::DONT_CARE) {
-        return;
+        return FALSE;
     }
 
     if (rawField < 0 || rawField >= UNUM_FIELD_COUNT) {
         status = U_ILLEGAL_ARGUMENT_ERROR;
-        return;
+        return FALSE;
     }
 
     auto field = static_cast<Field>(rawField);
 
     bool seenStart = false;
     int32_t fractionStart = -1;
-    for (int i = fZero; i <= fZero + fLength; i++) {
+    int32_t startIndex = fp.getEndIndex();
+    for (int i = fZero + startIndex; i <= fZero + fLength; i++) {
         Field _field = UNUM_FIELD_COUNT;
         if (i < fZero + fLength) {
             _field = getFieldPtr()[i];
@@ -434,10 +439,10 @@ void NumberStringBuilder::populateFieldPosition(FieldPosition &fp, int32_t offse
             if (field == UNUM_INTEGER_FIELD && _field == UNUM_GROUPING_SEPARATOR_FIELD) {
                 continue;
             }
-            fp.setEndIndex(i - fZero + offset);
+            fp.setEndIndex(i - fZero);
             break;
         } else if (!seenStart && field == _field) {
-            fp.setBeginIndex(i - fZero + offset);
+            fp.setBeginIndex(i - fZero);
             seenStart = true;
         }
         if (_field == UNUM_INTEGER_FIELD || _field == UNUM_DECIMAL_SEPARATOR_FIELD) {
@@ -445,36 +450,28 @@ void NumberStringBuilder::populateFieldPosition(FieldPosition &fp, int32_t offse
         }
     }
 
-    // Backwards compatibility: FRACTION needs to start after INTEGER if empty
-    if (field == UNUM_FRACTION_FIELD && !seenStart) {
-        fp.setBeginIndex(fractionStart + offset);
-        fp.setEndIndex(fractionStart + offset);
+    // Backwards compatibility: FRACTION needs to start after INTEGER if empty.
+    // Do not return that a field was found, though, since there is not actually a fraction part.
+    if (field == UNUM_FRACTION_FIELD && !seenStart && fractionStart != -1) {
+        fp.setBeginIndex(fractionStart);
+        fp.setEndIndex(fractionStart);
     }
-}
 
-void NumberStringBuilder::populateFieldPositionIterator(FieldPositionIterator &fpi, UErrorCode &status) const {
-    // TODO: Set an initial capacity on uvec?
-    LocalPointer <UVector32> uvec(new UVector32(status));
-    if (U_FAILURE(status)) {
-        return;
-    }
+    return seenStart;
+}
 
+void NumberStringBuilder::getAllFieldPositions(FieldPositionIteratorHandler& fpih,
+                                               UErrorCode& status) const {
     Field current = UNUM_FIELD_COUNT;
     int32_t currentStart = -1;
     for (int32_t i = 0; i < fLength; i++) {
         Field field = fieldAt(i);
         if (current == UNUM_INTEGER_FIELD && field == UNUM_GROUPING_SEPARATOR_FIELD) {
             // Special case: GROUPING_SEPARATOR counts as an INTEGER.
-            // Add the field, followed by the start index, followed by the end index to uvec.
-            uvec->addElement(UNUM_GROUPING_SEPARATOR_FIELD, status);
-            uvec->addElement(i, status);
-            uvec->addElement(i + 1, status);
+            fpih.addAttribute(UNUM_GROUPING_SEPARATOR_FIELD, i, i + 1);
         } else if (current != field) {
             if (current != UNUM_FIELD_COUNT) {
-                // Add the field, followed by the start index, followed by the end index to uvec.
-                uvec->addElement(current, status);
-                uvec->addElement(currentStart, status);
-                uvec->addElement(i, status);
+                fpih.addAttribute(current, currentStart, i);
             }
             current = field;
             currentStart = i;
@@ -484,14 +481,8 @@ void NumberStringBuilder::populateFieldPositionIterator(FieldPositionIterator &f
         }
     }
     if (current != UNUM_FIELD_COUNT) {
-        // Add the field, followed by the start index, followed by the end index to uvec.
-        uvec->addElement(current, status);
-        uvec->addElement(currentStart, status);
-        uvec->addElement(fLength, status);
+        fpih.addAttribute(current, currentStart, fLength);
     }
-
-    // Give uvec to the FieldPositionIterator, which adopts it.
-    fpi.setData(uvec.orphan(), status);
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_stringbuilder.h b/deps/icu-small/source/i18n/number_stringbuilder.h
index a97cc9ca026ad0..cd8ce2f805e994 100644
--- a/deps/icu-small/source/i18n/number_stringbuilder.h
+++ b/deps/icu-small/source/i18n/number_stringbuilder.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_STRINGBUILDER_H__
 #define __NUMBER_STRINGBUILDER_H__
 
@@ -14,6 +14,7 @@
 #include "cstring.h"
 #include "uassert.h"
 #include "number_types.h"
+#include "fphdlimp.h"
 
 U_NAMESPACE_BEGIN namespace number {
 namespace impl {
@@ -84,17 +85,26 @@ class U_I18N_API NumberStringBuilder : public UMemory {
 
     int32_t insert(int32_t index, const NumberStringBuilder &other, UErrorCode &status);
 
+    /**
+     * Gets a "safe" UnicodeString that can be used even after the NumberStringBuilder is destructed.
+     * */
     UnicodeString toUnicodeString() const;
 
+    /**
+     * Gets an "unsafe" UnicodeString that is valid only as long as the NumberStringBuilder is alive and
+     * unchanged. Slightly faster than toUnicodeString().
+     */
+    const UnicodeString toTempUnicodeString() const;
+
     UnicodeString toDebugString() const;
 
     const char16_t *chars() const;
 
     bool contentEquals(const NumberStringBuilder &other) const;
 
-    void populateFieldPosition(FieldPosition &fp, int32_t offset, UErrorCode &status) const;
+    bool nextFieldPosition(FieldPosition& fp, UErrorCode& status) const;
 
-    void populateFieldPositionIterator(FieldPositionIterator &fpi, UErrorCode &status) const;
+    void getAllFieldPositions(FieldPositionIteratorHandler& fpih, UErrorCode& status) const;
 
   private:
     bool fUsingHeap = false;
diff --git a/deps/icu-small/source/i18n/number_types.h b/deps/icu-small/source/i18n/number_types.h
index c01765e2cea6c6..57da72f8aa0ac1 100644
--- a/deps/icu-small/source/i18n/number_types.h
+++ b/deps/icu-small/source/i18n/number_types.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_TYPES_H__
 #define __NUMBER_TYPES_H__
 
@@ -15,9 +15,9 @@
 #include "unicode/utf16.h"
 #include "uassert.h"
 #include "unicode/platform.h"
+#include "unicode/uniset.h"
 
-U_NAMESPACE_BEGIN
-namespace number {
+U_NAMESPACE_BEGIN namespace number {
 namespace impl {
 
 // Typedef several enums for brevity and for easier comparison to Java.
@@ -39,9 +39,6 @@ static constexpr RoundingMode kDefaultMode = RoundingMode::UNUM_FOUND_HALFEVEN;
 // ICU4J Equivalent: Padder.FALLBACK_PADDING_STRING
 static constexpr char16_t kFallbackPaddingString[] = u" ";
 
-// ICU4J Equivalent: NumberFormatterImpl.DEFAULT_CURRENCY
-static constexpr char16_t kDefaultCurrency[] = u"XXX";
-
 // Forward declarations:
 
 class Modifier;
@@ -87,35 +84,10 @@ enum AffixPatternType {
 };
 
 enum CompactType {
-    TYPE_DECIMAL,
-    TYPE_CURRENCY
+    TYPE_DECIMAL, TYPE_CURRENCY
 };
 
 
-// TODO: Should this be moved somewhere else, maybe where other ICU classes can use it?
-// Exported as U_I18N_API because it is a base class for other exported types
-class U_I18N_API CharSequence {
-public:
-    virtual ~CharSequence() = default;
-
-    virtual int32_t length() const = 0;
-
-    virtual char16_t charAt(int32_t index) const = 0;
-
-    virtual UChar32 codePointAt(int32_t index) const {
-        // Default implementation; can be overridden with a more efficient version
-        char16_t leading = charAt(index);
-        if (U16_IS_LEAD(leading) && length() > index + 1) {
-            char16_t trailing = charAt(index + 1);
-            return U16_GET_SUPPLEMENTARY(leading, trailing);
-        } else {
-            return leading;
-        }
-    }
-
-    virtual UnicodeString toUnicodeString() const = 0;
-};
-
 class U_I18N_API AffixPatternProvider {
   public:
     static const int32_t AFFIX_PLURAL_MASK = 0xff;
@@ -123,12 +95,20 @@ class U_I18N_API AffixPatternProvider {
     static const int32_t AFFIX_NEGATIVE_SUBPATTERN = 0x200;
     static const int32_t AFFIX_PADDING = 0x400;
 
-    virtual ~AffixPatternProvider() = default;
+    // Convenience compound flags
+    static const int32_t AFFIX_POS_PREFIX = AFFIX_PREFIX;
+    static const int32_t AFFIX_POS_SUFFIX = 0;
+    static const int32_t AFFIX_NEG_PREFIX = AFFIX_PREFIX | AFFIX_NEGATIVE_SUBPATTERN;
+    static const int32_t AFFIX_NEG_SUFFIX = AFFIX_NEGATIVE_SUBPATTERN;
+
+    virtual ~AffixPatternProvider();
 
     virtual char16_t charAt(int flags, int i) const = 0;
 
     virtual int length(int flags) const = 0;
 
+    virtual UnicodeString getString(int flags) const = 0;
+
     virtual bool hasCurrencySign() const = 0;
 
     virtual bool positiveHasPlusSign() const = 0;
@@ -137,7 +117,7 @@ class U_I18N_API AffixPatternProvider {
 
     virtual bool negativeHasMinusSign() const = 0;
 
-    virtual bool containsSymbolType(AffixPatternType, UErrorCode &) const = 0;
+    virtual bool containsSymbolType(AffixPatternType, UErrorCode&) const = 0;
 
     /**
      * True if the pattern has a number placeholder like "0" or "#,##0.00"; false if the pattern does not
@@ -159,7 +139,7 @@ class U_I18N_API AffixPatternProvider {
  */
 class U_I18N_API Modifier {
   public:
-    virtual ~Modifier() = default;
+    virtual ~Modifier();
 
     /**
      * Apply this Modifier to the string builder.
@@ -173,8 +153,8 @@ class U_I18N_API Modifier {
      *            formatted.
      * @return The number of characters (UTF-16 code units) that were added to the string builder.
      */
-    virtual int32_t
-    apply(NumberStringBuilder &output, int leftIndex, int rightIndex, UErrorCode &status) const = 0;
+    virtual int32_t apply(NumberStringBuilder& output, int leftIndex, int rightIndex,
+                          UErrorCode& status) const = 0;
 
     /**
      * Gets the length of the prefix. This information can be used in combination with {@link #apply} to extract the
@@ -187,7 +167,7 @@ class U_I18N_API Modifier {
     /**
      * Returns the number of code points in the modifier, prefix plus suffix.
      */
-    virtual int32_t getCodePointCount(UErrorCode &status) const = 0;
+    virtual int32_t getCodePointCount(UErrorCode& status) const = 0;
 
     /**
      * Whether this modifier is strong. If a modifier is strong, it should always be applied immediately and not allowed
@@ -219,7 +199,7 @@ class U_I18N_API Modifier {
  */
 class U_I18N_API MicroPropsGenerator {
   public:
-    virtual ~MicroPropsGenerator() = default;
+    virtual ~MicroPropsGenerator();
 
     /**
      * Considers the given {@link DecimalQuantity}, optionally mutates it, and returns a {@link MicroProps}.
@@ -230,7 +210,8 @@ class U_I18N_API MicroPropsGenerator {
      *            The MicroProps instance to populate.
      * @return A MicroProps instance resolved for the quantity.
      */
-    virtual void processQuantity(DecimalQuantity& quantity, MicroProps& micros, UErrorCode& status) const = 0;
+    virtual void processQuantity(DecimalQuantity& quantity, MicroProps& micros,
+                                 UErrorCode& status) const = 0;
 };
 
 /**
@@ -238,7 +219,7 @@ class U_I18N_API MicroPropsGenerator {
  */
 class MultiplierProducer {
   public:
-    virtual ~MultiplierProducer() = default;
+    virtual ~MultiplierProducer();
 
     /**
      * Maps a magnitude to a multiplier in powers of ten. For example, in compact notation in English, a magnitude of 5
@@ -255,24 +236,31 @@ class MultiplierProducer {
 template<typename T>
 class U_I18N_API NullableValue {
   public:
-    NullableValue() : fNull(true) {}
+    NullableValue()
+            : fNull(true) {}
 
-    NullableValue(const NullableValue<T> &other) = default;
+    NullableValue(const NullableValue<T>& other) = default;
 
-    explicit NullableValue(const T &other) {
+    explicit NullableValue(const T& other) {
         fValue = other;
         fNull = false;
     }
 
-    NullableValue<T> &operator=(const NullableValue<T> &other) = default;
+    NullableValue<T>& operator=(const NullableValue<T>& other) {
+        fNull = other.fNull;
+        if (!fNull) {
+            fValue = other.fValue;
+        }
+        return *this;
+    }
 
-    NullableValue<T> &operator=(const T &other) {
+    NullableValue<T>& operator=(const T& other) {
         fValue = other;
         fNull = false;
         return *this;
     }
 
-    bool operator==(const NullableValue &other) const {
+    bool operator==(const NullableValue& other) const {
         // "fValue == other.fValue" returns UBool, not bool (causes compiler warnings)
         return fNull ? other.fNull : (other.fNull ? false : static_cast<bool>(fValue == other.fValue));
     }
@@ -286,13 +274,21 @@ class U_I18N_API NullableValue {
         return fNull;
     }
 
-    T get(UErrorCode &status) const {
+    T get(UErrorCode& status) const {
         if (fNull) {
             status = U_UNDEFINED_VARIABLE;
         }
         return fValue;
     }
 
+    T getNoError() const {
+        return fValue;
+    }
+
+    T getOrDefault(T defaultValue) const {
+        return fNull ? defaultValue : fValue;
+    }
+
   private:
     bool fNull;
     T fValue;
diff --git a/deps/icu-small/source/i18n/number_utils.cpp b/deps/icu-small/source/i18n/number_utils.cpp
new file mode 100644
index 00000000000000..c79d2de9fa3f55
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_utils.cpp
@@ -0,0 +1,253 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include <stdlib.h>
+#include <cmath>
+#include "number_decnum.h"
+#include "number_types.h"
+#include "number_utils.h"
+#include "charstr.h"
+#include "decContext.h"
+#include "decNumber.h"
+#include "double-conversion.h"
+#include "fphdlimp.h"
+#include "uresimp.h"
+#include "ureslocs.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+using icu::double_conversion::DoubleToStringConverter;
+
+
+namespace {
+
+const char16_t*
+doGetPattern(UResourceBundle* res, const char* nsName, const char* patternKey, UErrorCode& publicStatus,
+             UErrorCode& localStatus) {
+    // Construct the path into the resource bundle
+    CharString key;
+    key.append("NumberElements/", publicStatus);
+    key.append(nsName, publicStatus);
+    key.append("/patterns/", publicStatus);
+    key.append(patternKey, publicStatus);
+    if (U_FAILURE(publicStatus)) {
+        return u"";
+    }
+    return ures_getStringByKeyWithFallback(res, key.data(), nullptr, &localStatus);
+}
+
+}
+
+
+const char16_t* utils::getPatternForStyle(const Locale& locale, const char* nsName, CldrPatternStyle style,
+                                          UErrorCode& status) {
+    const char* patternKey;
+    switch (style) {
+        case CLDR_PATTERN_STYLE_DECIMAL:
+            patternKey = "decimalFormat";
+            break;
+        case CLDR_PATTERN_STYLE_CURRENCY:
+            patternKey = "currencyFormat";
+            break;
+        case CLDR_PATTERN_STYLE_ACCOUNTING:
+            patternKey = "accountingFormat";
+            break;
+        case CLDR_PATTERN_STYLE_PERCENT:
+            patternKey = "percentFormat";
+            break;
+        case CLDR_PATTERN_STYLE_SCIENTIFIC:
+            patternKey = "scientificFormat";
+            break;
+        default:
+            patternKey = "decimalFormat"; // silence compiler error
+            U_ASSERT(false);
+    }
+    LocalUResourceBundlePointer res(ures_open(nullptr, locale.getName(), &status));
+    if (U_FAILURE(status)) { return u""; }
+
+    // Attempt to get the pattern with the native numbering system.
+    UErrorCode localStatus = U_ZERO_ERROR;
+    const char16_t* pattern;
+    pattern = doGetPattern(res.getAlias(), nsName, patternKey, status, localStatus);
+    if (U_FAILURE(status)) { return u""; }
+
+    // Fall back to latn if native numbering system does not have the right pattern
+    if (U_FAILURE(localStatus) && uprv_strcmp("latn", nsName) != 0) {
+        localStatus = U_ZERO_ERROR;
+        pattern = doGetPattern(res.getAlias(), "latn", patternKey, status, localStatus);
+        if (U_FAILURE(status)) { return u""; }
+    }
+
+    return pattern;
+}
+
+
+DecNum::DecNum() {
+    uprv_decContextDefault(&fContext, DEC_INIT_BASE);
+    uprv_decContextSetRounding(&fContext, DEC_ROUND_HALF_EVEN);
+    fContext.traps = 0; // no traps, thank you (what does this even mean?)
+}
+
+DecNum::DecNum(const DecNum& other, UErrorCode& status)
+        : fContext(other.fContext) {
+    // Allocate memory for the new DecNum.
+    U_ASSERT(fContext.digits == other.fData.getCapacity());
+    if (fContext.digits > kDefaultDigits) {
+        void* p = fData.resize(fContext.digits, 0);
+        if (p == nullptr) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
+    }
+
+    // Copy the data from the old DecNum to the new one.
+    uprv_memcpy(fData.getAlias(), other.fData.getAlias(), sizeof(decNumber));
+    uprv_memcpy(fData.getArrayStart(),
+            other.fData.getArrayStart(),
+            other.fData.getArrayLimit() - other.fData.getArrayStart());
+}
+
+void DecNum::setTo(StringPiece str, UErrorCode& status) {
+    // We need NUL-terminated for decNumber; CharString guarantees this, but not StringPiece.
+    CharString cstr(str, status);
+    if (U_FAILURE(status)) { return; }
+    _setTo(cstr.data(), str.length(), status);
+}
+
+void DecNum::setTo(const char* str, UErrorCode& status) {
+    _setTo(str, static_cast<int32_t>(uprv_strlen(str)), status);
+}
+
+void DecNum::setTo(double d, UErrorCode& status) {
+    // Need to check for NaN and Infinity before going into DoubleToStringConverter
+    if (std::isnan(d) != 0 || std::isfinite(d) == 0) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+    // First convert from double to string, then string to DecNum.
+    // Allocate enough room for: all digits, "E-324", and NUL-terminator.
+    char buffer[DoubleToStringConverter::kBase10MaximalLength + 6];
+    bool sign; // unused; always positive
+    int32_t length;
+    int32_t point;
+    DoubleToStringConverter::DoubleToAscii(
+            d,
+            DoubleToStringConverter::DtoaMode::SHORTEST,
+            0,
+            buffer,
+            sizeof(buffer),
+            &sign,
+            &length,
+            &point
+    );
+
+    // Read initial result as a string.
+    _setTo(buffer, length, status);
+
+    // Set exponent and bitmask. Note that DoubleToStringConverter does not do negatives.
+    fData.getAlias()->exponent += point - length;
+    fData.getAlias()->bits |= static_cast<uint8_t>(std::signbit(d) ? DECNEG : 0);
+}
+
+void DecNum::_setTo(const char* str, int32_t maxDigits, UErrorCode& status) {
+    if (maxDigits > kDefaultDigits) {
+        fData.resize(maxDigits, 0);
+        fContext.digits = maxDigits;
+    } else {
+        fContext.digits = kDefaultDigits;
+    }
+
+    static_assert(DECDPUN == 1, "Assumes that DECDPUN is set to 1");
+    uprv_decNumberFromString(fData.getAlias(), str, &fContext);
+
+    // Check for invalid syntax and set the corresponding error code.
+    if ((fContext.status & DEC_Conversion_syntax) != 0) {
+        status = U_DECIMAL_NUMBER_SYNTAX_ERROR;
+        return;
+    } else if (fContext.status != 0) {
+        // Not a syntax error, but some other error, like an exponent that is too large.
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+    // For consistency with Java BigDecimal, no support for DecNum that is NaN or Infinity!
+    if (decNumberIsSpecial(fData.getAlias())) {
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+}
+
+void
+DecNum::setTo(const uint8_t* bcd, int32_t length, int32_t scale, bool isNegative, UErrorCode& status) {
+    if (length > kDefaultDigits) {
+        fData.resize(length, 0);
+        fContext.digits = length;
+    } else {
+        fContext.digits = kDefaultDigits;
+    }
+
+    // "digits is of type int32_t, and must have a value in the range 1 through 999,999,999."
+    if (length < 1 || length > 999999999) {
+        // Too large for decNumber
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+    // "The exponent field holds the exponent of the number. Its range is limited by the requirement that
+    // "the range of the adjusted exponent of the number be balanced and fit within a whole number of
+    // "decimal digits (in this implementation, be –999,999,999 through +999,999,999). The adjusted
+    // "exponent is the exponent that would result if the number were expressed with a single digit before
+    // "the decimal point, and is therefore given by exponent+digits-1."
+    if (scale > 999999999 - length + 1 || scale < -999999999 - length + 1) {
+        // Too large for decNumber
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
+    fData.getAlias()->digits = length;
+    fData.getAlias()->exponent = scale;
+    fData.getAlias()->bits = static_cast<uint8_t>(isNegative ? DECNEG : 0);
+    uprv_decNumberSetBCD(fData, bcd, static_cast<uint32_t>(length));
+    if (fContext.status != 0) {
+        // Some error occurred while constructing the decNumber.
+        status = U_INTERNAL_PROGRAM_ERROR;
+    }
+}
+
+void DecNum::normalize() {
+    uprv_decNumberReduce(fData, fData, &fContext);
+}
+
+void DecNum::multiplyBy(const DecNum& rhs, UErrorCode& status) {
+    uprv_decNumberMultiply(fData, fData, rhs.fData, &fContext);
+    if (fContext.status != 0) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+    }
+}
+
+void DecNum::divideBy(const DecNum& rhs, UErrorCode& status) {
+    uprv_decNumberDivide(fData, fData, rhs.fData, &fContext);
+    if (fContext.status != 0) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+    }
+}
+
+bool DecNum::isNegative() const {
+    return decNumberIsNegative(fData.getAlias());
+}
+
+bool DecNum::isZero() const {
+    return decNumberIsZero(fData.getAlias());
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/number_utils.h b/deps/icu-small/source/i18n/number_utils.h
index 3a408d6007a2cd..c367166009c0dc 100644
--- a/deps/icu-small/source/i18n/number_utils.h
+++ b/deps/icu-small/source/i18n/number_utils.h
@@ -3,7 +3,7 @@
 
 #include "unicode/utypes.h"
 
-#if !UCONFIG_NO_FORMATTING && !UPRV_INCOMPLETE_CPP11_SUPPORT
+#if !UCONFIG_NO_FORMATTING
 #ifndef __NUMBER_UTILS_H__
 #define __NUMBER_UTILS_H__
 
@@ -13,116 +13,80 @@
 #include "number_scientific.h"
 #include "number_patternstring.h"
 #include "number_modifiers.h"
+#include "number_multiplier.h"
+#include "number_roundingutils.h"
+#include "decNumber.h"
+#include "charstr.h"
 
-U_NAMESPACE_BEGIN namespace number {
-namespace impl {
+U_NAMESPACE_BEGIN
 
-class UnicodeStringCharSequence : public CharSequence {
-  public:
-    explicit UnicodeStringCharSequence(const UnicodeString &other) {
-        fStr = other;
-    }
+namespace number {
+namespace impl {
 
-    ~UnicodeStringCharSequence() U_OVERRIDE = default;
+enum CldrPatternStyle {
+    CLDR_PATTERN_STYLE_DECIMAL,
+    CLDR_PATTERN_STYLE_CURRENCY,
+    CLDR_PATTERN_STYLE_ACCOUNTING,
+    CLDR_PATTERN_STYLE_PERCENT,
+    CLDR_PATTERN_STYLE_SCIENTIFIC,
+    CLDR_PATTERN_STYLE_COUNT,
+};
 
-    int32_t length() const U_OVERRIDE {
-        return fStr.length();
-    }
+// Namespace for naked functions
+namespace utils {
 
-    char16_t charAt(int32_t index) const U_OVERRIDE {
-        return fStr.charAt(index);
+inline int32_t insertDigitFromSymbols(NumberStringBuilder& output, int32_t index, int8_t digit,
+                                      const DecimalFormatSymbols& symbols, Field field,
+                                      UErrorCode& status) {
+    if (symbols.getCodePointZero() != -1) {
+        return output.insertCodePoint(index, symbols.getCodePointZero() + digit, field, status);
     }
+    return output.insert(index, symbols.getConstDigitSymbol(digit), field, status);
+}
 
-    UChar32 codePointAt(int32_t index) const U_OVERRIDE {
-        return fStr.char32At(index);
-    }
+inline bool unitIsCurrency(const MeasureUnit& unit) {
+    return uprv_strcmp("currency", unit.getType()) == 0;
+}
 
-    UnicodeString toUnicodeString() const U_OVERRIDE {
-        // Allocate a UnicodeString of the correct length
-        UnicodeString output(length(), 0, -1);
-        for (int32_t i = 0; i < length(); i++) {
-            output.append(charAt(i));
-        }
-        return output;
-    }
+inline bool unitIsNoUnit(const MeasureUnit& unit) {
+    return uprv_strcmp("none", unit.getType()) == 0;
+}
 
-  private:
-    UnicodeString fStr;
-};
+inline bool unitIsPercent(const MeasureUnit& unit) {
+    return uprv_strcmp("percent", unit.getSubtype()) == 0;
+}
 
-struct MicroProps : public MicroPropsGenerator {
-
-    // NOTE: All of these fields are properly initialized in NumberFormatterImpl.
-    Rounder rounding;
-    Grouper grouping;
-    Padder padding;
-    IntegerWidth integerWidth;
-    UNumberSignDisplay sign;
-    UNumberDecimalSeparatorDisplay decimal;
-    bool useCurrency;
-
-    // Note: This struct has no direct ownership of the following pointers.
-    const DecimalFormatSymbols *symbols;
-    const Modifier *modOuter;
-    const Modifier *modMiddle;
-    const Modifier *modInner;
-
-    // The following "helper" fields may optionally be used during the MicroPropsGenerator.
-    // They live here to retain memory.
-    struct {
-        ScientificModifier scientificModifier;
-        EmptyModifier emptyWeakModifier{false};
-        EmptyModifier emptyStrongModifier{true};
-    } helpers;
-
-
-    MicroProps() = default;
-
-    MicroProps(const MicroProps &other) = default;
-
-    MicroProps &operator=(const MicroProps &other) = default;
-
-    void processQuantity(DecimalQuantity &, MicroProps &micros, UErrorCode &status) const U_OVERRIDE {
-        (void)status;
-        if (this == &micros) {
-            // Unsafe path: no need to perform a copy.
-            U_ASSERT(!exhausted);
-            micros.exhausted = true;
-            U_ASSERT(exhausted);
-        } else {
-            // Safe path: copy self into the output micros.
-            micros = *this;
-        }
-    }
+inline bool unitIsPermille(const MeasureUnit& unit) {
+    return uprv_strcmp("permille", unit.getSubtype()) == 0;
+}
 
-  private:
-    // Internal fields:
-    bool exhausted = false;
-};
+// NOTE: In Java, this method is in NumberFormat.java
+const char16_t*
+getPatternForStyle(const Locale& locale, const char* nsName, CldrPatternStyle style, UErrorCode& status);
 
 /**
- * This struct provides the result of the number formatting pipeline to FormattedNumber.
+ * Computes the plural form for this number based on the specified set of rules.
  *
- * The DecimalQuantity is not currently being used by FormattedNumber, but at some point it could be used
- * to add a toDecNumber() or similar method.
+ * @param rules A {@link PluralRules} object representing the set of rules.
+ * @return The {@link StandardPlural} according to the PluralRules. If the plural form is not in
+ *     the set of standard plurals, {@link StandardPlural#OTHER} is returned instead.
  */
-struct NumberFormatterResults : public UMemory {
-    DecimalQuantity quantity;
-    NumberStringBuilder string;
-};
-
-inline const UnicodeString getDigitFromSymbols(int8_t digit, const DecimalFormatSymbols &symbols) {
-    // TODO: Implement DecimalFormatSymbols.getCodePointZero()?
-    if (digit == 0) {
-        return symbols.getSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kZeroDigitSymbol);
+inline StandardPlural::Form getStandardPlural(const PluralRules *rules,
+                                              const IFixedDecimal &fdec) {
+    if (rules == nullptr) {
+        // Fail gracefully if the user didn't provide a PluralRules
+        return StandardPlural::Form::OTHER;
     } else {
-        return symbols.getSymbol(static_cast<DecimalFormatSymbols::ENumberFormatSymbol>(
-                                         DecimalFormatSymbols::ENumberFormatSymbol::kOneDigitSymbol + digit - 1));
+        UnicodeString ruleString = rules->select(fdec);
+        return StandardPlural::orOtherFromString(ruleString);
     }
 }
 
+} // namespace utils
+
 } // namespace impl
 } // namespace number
+
 U_NAMESPACE_END
 
 #endif //__NUMBER_UTILS_H__
diff --git a/deps/icu-small/source/i18n/number_utypes.h b/deps/icu-small/source/i18n/number_utypes.h
new file mode 100644
index 00000000000000..48bfce1969754a
--- /dev/null
+++ b/deps/icu-small/source/i18n/number_utypes.h
@@ -0,0 +1,79 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMBER_UTYPES_H__
+#define __SOURCE_NUMBER_UTYPES_H__
+
+#include "unicode/numberformatter.h"
+#include "number_types.h"
+#include "number_decimalquantity.h"
+#include "number_stringbuilder.h"
+
+U_NAMESPACE_BEGIN namespace number {
+namespace impl {
+
+
+/**
+ * Implementation class for UNumberFormatter with a magic number for safety.
+ *
+ * Wraps a LocalizedNumberFormatter by value.
+ */
+struct UNumberFormatterData : public UMemory {
+    // The magic number to identify incoming objects.
+    // Reads in ASCII as "NFR" (NumberFormatteR with room at the end)
+    static constexpr int32_t kMagic = 0x4E465200;
+
+    // Data members:
+    int32_t fMagic = kMagic;
+    LocalizedNumberFormatter fFormatter;
+
+    /** Convert from UNumberFormatter -> UNumberFormatterData. */
+    static UNumberFormatterData* validate(UNumberFormatter* input, UErrorCode& status);
+
+    /** Convert from UNumberFormatter -> UNumberFormatterData (const version). */
+    static const UNumberFormatterData* validate(const UNumberFormatter* input, UErrorCode& status);
+
+    /** Convert from UNumberFormatterData -> UNumberFormatter. */
+    UNumberFormatter* exportForC();
+};
+
+
+/**
+ * Implementation class for UFormattedNumber with magic number for safety.
+ *
+ * This struct is also held internally by the C++ version FormattedNumber since the member types are not
+ * declared in the public header file.
+ *
+ * The DecimalQuantity is not currently being used by FormattedNumber, but at some point it could be used
+ * to add a toDecNumber() or similar method.
+ */
+struct UFormattedNumberData : public UMemory {
+    // The magic number to identify incoming objects.
+    // Reads in ASCII as "FDN" (FormatteDNumber with room at the end)
+    static constexpr int32_t kMagic = 0x46444E00;
+
+    // Data members:
+    int32_t fMagic = kMagic;
+    DecimalQuantity quantity;
+    NumberStringBuilder string;
+
+    /** Convert from UFormattedNumber -> UFormattedNumberData. */
+    static UFormattedNumberData* validate(UFormattedNumber* input, UErrorCode& status);
+
+    /** Convert from UFormattedNumber -> UFormattedNumberData (const version). */
+    static const UFormattedNumberData* validate(const UFormattedNumber* input, UErrorCode& status);
+
+    /** Convert from UFormattedNumberData -> UFormattedNumber. */
+    UFormattedNumber* exportForC();
+};
+
+
+} // namespace impl
+} // namespace number
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMBER_UTYPES_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numfmt.cpp b/deps/icu-small/source/i18n/numfmt.cpp
index fee3bed8bfb352..13f23131b1851b 100644
--- a/deps/icu-small/source/i18n/numfmt.cpp
+++ b/deps/icu-small/source/i18n/numfmt.cpp
@@ -51,10 +51,11 @@
 #include "uassert.h"
 #include "umutex.h"
 #include "mutex.h"
-#include "digitlst.h"
 #include <float.h>
 #include "sharednumberformat.h"
 #include "unifiedcache.h"
+#include "number_decimalquantity.h"
+#include "number_utils.h"
 
 //#define FMT_DEBUG
 
@@ -129,31 +130,28 @@ static const UChar * const gLastResortNumberPatterns[UNUM_FORMAT_STYLE_COUNT] =
 
 // Keys used for accessing resource bundles
 
-static const char *gNumberElements = "NumberElements";
-static const char *gLatn = "latn";
-static const char *gPatterns = "patterns";
-static const char *gFormatKeys[UNUM_FORMAT_STYLE_COUNT] = {
-    NULL,  // UNUM_PATTERN_DECIMAL
-    "decimalFormat",  // UNUM_DECIMAL
-    "currencyFormat",  // UNUM_CURRENCY
-    "percentFormat",  // UNUM_PERCENT
-    "scientificFormat",  // UNUM_SCIENTIFIC
-    NULL,  // UNUM_SPELLOUT
-    NULL,  // UNUM_ORDINAL
-    NULL,  // UNUM_DURATION
-    NULL,  // UNUM_NUMBERING_SYSTEM
-    NULL,  // UNUM_PATTERN_RULEBASED
+static const icu::number::impl::CldrPatternStyle gFormatCldrStyles[UNUM_FORMAT_STYLE_COUNT] = {
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_PATTERN_DECIMAL
+    icu::number::impl::CLDR_PATTERN_STYLE_DECIMAL,  // UNUM_DECIMAL
+    icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY,  // UNUM_CURRENCY
+    icu::number::impl::CLDR_PATTERN_STYLE_PERCENT,  // UNUM_PERCENT
+    icu::number::impl::CLDR_PATTERN_STYLE_SCIENTIFIC,  // UNUM_SCIENTIFIC
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_SPELLOUT
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_ORDINAL
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_DURATION
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_NUMBERING_SYSTEM
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_PATTERN_RULEBASED
     // For UNUM_CURRENCY_ISO and UNUM_CURRENCY_PLURAL,
     // the pattern is the same as the pattern of UNUM_CURRENCY
     // except for replacing the single currency sign with
     // double currency sign or triple currency sign.
-    "currencyFormat",  // UNUM_CURRENCY_ISO
-    "currencyFormat",  // UNUM_CURRENCY_PLURAL
-    "accountingFormat",  // UNUM_CURRENCY_ACCOUNTING
-    "currencyFormat",  // UNUM_CASH_CURRENCY
-    NULL,  // UNUM_DECIMAL_COMPACT_SHORT
-    NULL,  // UNUM_DECIMAL_COMPACT_LONG
-    "currencyFormat",  // UNUM_CURRENCY_STANDARD
+    icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY,  // UNUM_CURRENCY_ISO
+    icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY,  // UNUM_CURRENCY_PLURAL
+    icu::number::impl::CLDR_PATTERN_STYLE_ACCOUNTING,  // UNUM_CURRENCY_ACCOUNTING
+    icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY,  // UNUM_CASH_CURRENCY
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_DECIMAL_COMPACT_SHORT
+    /* NULL */ icu::number::impl::CLDR_PATTERN_STYLE_COUNT,  // UNUM_DECIMAL_COMPACT_LONG
+    icu::number::impl::CLDR_PATTERN_STYLE_CURRENCY,  // UNUM_CURRENCY_STANDARD
 };
 
 // Static hashtable cache of NumberingSystem objects used by NumberFormat
@@ -524,7 +522,7 @@ ArgExtractor::ArgExtractor(const NumberFormat& /*nf*/, const Formattable& obj, U
 ArgExtractor::~ArgExtractor() {
 }
 
-UnicodeString& NumberFormat::format(const DigitList &number,
+UnicodeString& NumberFormat::format(const number::impl::DecimalQuantity &number,
                       UnicodeString& appendTo,
                       FieldPositionIterator* posIter,
                       UErrorCode& status) const {
@@ -534,7 +532,7 @@ UnicodeString& NumberFormat::format(const DigitList &number,
     if (U_FAILURE(status)) {
         return appendTo;
     }
-    double dnum = number.getDouble();
+    double dnum = number.toDouble();
     format(dnum, appendTo, posIter, status);
     return appendTo;
 }
@@ -542,7 +540,7 @@ UnicodeString& NumberFormat::format(const DigitList &number,
 
 
 UnicodeString&
-NumberFormat::format(const DigitList &number,
+NumberFormat::format(const number::impl::DecimalQuantity &number,
                      UnicodeString& appendTo,
                      FieldPosition& pos,
                      UErrorCode &status) const {
@@ -552,7 +550,7 @@ NumberFormat::format(const DigitList &number,
     if (U_FAILURE(status)) {
         return appendTo;
     }
-    double dnum = number.getDouble();
+    double dnum = number.toDouble();
     format(dnum, appendTo, pos, status);
     return appendTo;
 }
@@ -578,7 +576,7 @@ NumberFormat::format(const Formattable& obj,
       return cloneFmt->format(*n, appendTo, pos, status);
     }
 
-    if (n->isNumeric() && n->getDigitList() != NULL) {
+    if (n->isNumeric() && n->getDecimalQuantity() != NULL) {
         // Decimal Number.  We will have a DigitList available if the value was
         //   set to a decimal number, or if the value originated with a parse.
         //
@@ -587,17 +585,17 @@ NumberFormat::format(const Formattable& obj,
         // know about DigitList to continue to operate as they had.
         //
         // DecimalFormat overrides the DigitList formatting functions.
-        format(*n->getDigitList(), appendTo, pos, status);
+        format(*n->getDecimalQuantity(), appendTo, pos, status);
     } else {
         switch (n->getType()) {
         case Formattable::kDouble:
-            format(n->getDouble(), appendTo, pos);
+            format(n->getDouble(), appendTo, pos, status);
             break;
         case Formattable::kLong:
-            format(n->getLong(), appendTo, pos);
+            format(n->getLong(), appendTo, pos, status);
             break;
         case Formattable::kInt64:
-            format(n->getInt64(), appendTo, pos);
+            format(n->getInt64(), appendTo, pos, status);
             break;
         default:
             status = U_INVALID_FORMAT_ERROR;
@@ -633,9 +631,9 @@ NumberFormat::format(const Formattable& obj,
       return cloneFmt->format(*n, appendTo, posIter, status);
     }
 
-    if (n->isNumeric() && n->getDigitList() != NULL) {
+    if (n->isNumeric() && n->getDecimalQuantity() != NULL) {
         // Decimal Number
-        format(*n->getDigitList(), appendTo, posIter, status);
+        format(*n->getDecimalQuantity(), appendTo, posIter, status);
     } else {
         switch (n->getType()) {
         case Formattable::kDouble:
@@ -1400,27 +1398,13 @@ NumberFormat::makeInstance(const Locale& desiredLocale,
             return NULL;
         }
 
-        UResourceBundle *resource = ownedResource.orphan();
-        UResourceBundle *numElements = ures_getByKeyWithFallback(resource, gNumberElements, NULL, &status);
-        resource = ures_getByKeyWithFallback(numElements, ns->getName(), resource, &status);
-        resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
-        ownedResource.adoptInstead(resource);
-
-        int32_t patLen = 0;
-        const UChar *patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
-
-        // Didn't find a pattern specific to the numbering system, so fall back to "latn"
-        if ( status == U_MISSING_RESOURCE_ERROR && uprv_strcmp(gLatn,ns->getName())) {
-            status = U_ZERO_ERROR;
-            resource = ures_getByKeyWithFallback(numElements, gLatn, resource, &status);
-            resource = ures_getByKeyWithFallback(resource, gPatterns, resource, &status);
-            patResStr = ures_getStringByKeyWithFallback(resource, gFormatKeys[style], &patLen, &status);
-        }
-
-        ures_close(numElements);
-
-        // Creates the specified decimal format style of the desired locale.
-        pattern.setTo(TRUE, patResStr, patLen);
+        // Load the pattern from data using the common library function
+        const char16_t* patternPtr = number::impl::utils::getPatternForStyle(
+                desiredLocale,
+                ns->getName(),
+                gFormatCldrStyles[style],
+                status);
+        pattern = UnicodeString(TRUE, patternPtr, -1);
     }
     if (U_FAILURE(status)) {
         return NULL;
diff --git a/deps/icu-small/source/i18n/numparse_affixes.cpp b/deps/icu-small/source/i18n/numparse_affixes.cpp
new file mode 100644
index 00000000000000..c30d241693c8bf
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_affixes.cpp
@@ -0,0 +1,470 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_affixes.h"
+#include "numparse_utils.h"
+#include "number_utils.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+
+namespace {
+
+/**
+ * Helper method to return whether the given AffixPatternMatcher equals the given pattern string.
+ * Either both arguments must be null or the pattern string inside the AffixPatternMatcher must equal
+ * the given pattern string.
+ */
+static bool matched(const AffixPatternMatcher* affix, const UnicodeString& patternString) {
+    return (affix == nullptr && patternString.isBogus()) ||
+           (affix != nullptr && affix->getPattern() == patternString);
+}
+
+/**
+ * Helper method to return the length of the given AffixPatternMatcher. Returns 0 for null.
+ */
+static int32_t length(const AffixPatternMatcher* matcher) {
+    return matcher == nullptr ? 0 : matcher->getPattern().length();
+}
+
+/**
+ * Helper method to return whether (1) both lhs and rhs are null/invalid, or (2) if they are both
+ * valid, whether they are equal according to operator==.  Similar to Java Objects.equals()
+ */
+static bool equals(const AffixPatternMatcher* lhs, const AffixPatternMatcher* rhs) {
+    if (lhs == nullptr && rhs == nullptr) {
+        return true;
+    }
+    if (lhs == nullptr || rhs == nullptr) {
+        return false;
+    }
+    return *lhs == *rhs;
+}
+
+}
+
+
+AffixPatternMatcherBuilder::AffixPatternMatcherBuilder(const UnicodeString& pattern,
+                                                       AffixTokenMatcherWarehouse& warehouse,
+                                                       IgnorablesMatcher* ignorables)
+        : fMatchersLen(0),
+          fLastTypeOrCp(0),
+          fPattern(pattern),
+          fWarehouse(warehouse),
+          fIgnorables(ignorables) {}
+
+void AffixPatternMatcherBuilder::consumeToken(AffixPatternType type, UChar32 cp, UErrorCode& status) {
+    // This is called by AffixUtils.iterateWithConsumer() for each token.
+
+    // Add an ignorables matcher between tokens except between two literals, and don't put two
+    // ignorables matchers in a row.
+    if (fIgnorables != nullptr && fMatchersLen > 0 &&
+        (fLastTypeOrCp < 0 || !fIgnorables->getSet()->contains(fLastTypeOrCp))) {
+        addMatcher(*fIgnorables);
+    }
+
+    if (type != TYPE_CODEPOINT) {
+        // Case 1: the token is a symbol.
+        switch (type) {
+            case TYPE_MINUS_SIGN:
+                addMatcher(fWarehouse.minusSign());
+                break;
+            case TYPE_PLUS_SIGN:
+                addMatcher(fWarehouse.plusSign());
+                break;
+            case TYPE_PERCENT:
+                addMatcher(fWarehouse.percent());
+                break;
+            case TYPE_PERMILLE:
+                addMatcher(fWarehouse.permille());
+                break;
+            case TYPE_CURRENCY_SINGLE:
+            case TYPE_CURRENCY_DOUBLE:
+            case TYPE_CURRENCY_TRIPLE:
+            case TYPE_CURRENCY_QUAD:
+            case TYPE_CURRENCY_QUINT:
+                // All currency symbols use the same matcher
+                addMatcher(fWarehouse.currency(status));
+                break;
+            default:
+                U_ASSERT(FALSE);
+        }
+
+    } else if (fIgnorables != nullptr && fIgnorables->getSet()->contains(cp)) {
+        // Case 2: the token is an ignorable literal.
+        // No action necessary: the ignorables matcher has already been added.
+
+    } else {
+        // Case 3: the token is a non-ignorable literal.
+        addMatcher(fWarehouse.nextCodePointMatcher(cp));
+    }
+    fLastTypeOrCp = type != TYPE_CODEPOINT ? type : cp;
+}
+
+void AffixPatternMatcherBuilder::addMatcher(NumberParseMatcher& matcher) {
+    if (fMatchersLen >= fMatchers.getCapacity()) {
+        fMatchers.resize(fMatchersLen * 2, fMatchersLen);
+    }
+    fMatchers[fMatchersLen++] = &matcher;
+}
+
+AffixPatternMatcher AffixPatternMatcherBuilder::build() {
+    return AffixPatternMatcher(fMatchers, fMatchersLen, fPattern);
+}
+
+
+CodePointMatcherWarehouse::CodePointMatcherWarehouse()
+        : codePointCount(0), codePointNumBatches(0) {}
+
+CodePointMatcherWarehouse::~CodePointMatcherWarehouse() {
+    // Delete the variable number of batches of code point matchers
+    for (int32_t i = 0; i < codePointNumBatches; i++) {
+        delete[] codePointsOverflow[i];
+    }
+}
+
+CodePointMatcherWarehouse::CodePointMatcherWarehouse(CodePointMatcherWarehouse&& src) U_NOEXCEPT
+        : codePoints(std::move(src.codePoints)),
+          codePointsOverflow(std::move(src.codePointsOverflow)),
+          codePointCount(src.codePointCount),
+          codePointNumBatches(src.codePointNumBatches) {}
+
+CodePointMatcherWarehouse&
+CodePointMatcherWarehouse::operator=(CodePointMatcherWarehouse&& src) U_NOEXCEPT {
+    codePoints = std::move(src.codePoints);
+    codePointsOverflow = std::move(src.codePointsOverflow);
+    codePointCount = src.codePointCount;
+    codePointNumBatches = src.codePointNumBatches;
+    return *this;
+}
+
+NumberParseMatcher& CodePointMatcherWarehouse::nextCodePointMatcher(UChar32 cp) {
+    if (codePointCount < CODE_POINT_STACK_CAPACITY) {
+        return codePoints[codePointCount++] = {cp};
+    }
+    int32_t totalCapacity = CODE_POINT_STACK_CAPACITY + codePointNumBatches * CODE_POINT_BATCH_SIZE;
+    if (codePointCount >= totalCapacity) {
+        // Need a new batch
+        auto* nextBatch = new CodePointMatcher[CODE_POINT_BATCH_SIZE];
+        if (codePointNumBatches >= codePointsOverflow.getCapacity()) {
+            // Need more room for storing pointers to batches
+            codePointsOverflow.resize(codePointNumBatches * 2, codePointNumBatches);
+        }
+        codePointsOverflow[codePointNumBatches++] = nextBatch;
+    }
+    return codePointsOverflow[codePointNumBatches - 1][(codePointCount++ - CODE_POINT_STACK_CAPACITY) %
+                                                       CODE_POINT_BATCH_SIZE] = {cp};
+}
+
+
+AffixTokenMatcherWarehouse::AffixTokenMatcherWarehouse(const AffixTokenMatcherSetupData* setupData)
+        : fSetupData(setupData) {}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::minusSign() {
+    return fMinusSign = {fSetupData->dfs, true};
+}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::plusSign() {
+    return fPlusSign = {fSetupData->dfs, true};
+}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::percent() {
+    return fPercent = {fSetupData->dfs};
+}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::permille() {
+    return fPermille = {fSetupData->dfs};
+}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::currency(UErrorCode& status) {
+    return fCurrency = {fSetupData->currencySymbols, fSetupData->dfs, fSetupData->parseFlags, status};
+}
+
+IgnorablesMatcher& AffixTokenMatcherWarehouse::ignorables() {
+    return fSetupData->ignorables;
+}
+
+NumberParseMatcher& AffixTokenMatcherWarehouse::nextCodePointMatcher(UChar32 cp) {
+    return fCodePoints.nextCodePointMatcher(cp);
+}
+
+
+CodePointMatcher::CodePointMatcher(UChar32 cp)
+        : fCp(cp) {}
+
+bool CodePointMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode&) const {
+    if (segment.startsWith(fCp)) {
+        segment.adjustOffsetByCodePoint();
+        result.setCharsConsumed(segment);
+    }
+    return false;
+}
+
+bool CodePointMatcher::smokeTest(const StringSegment& segment) const {
+    return segment.startsWith(fCp);
+}
+
+UnicodeString CodePointMatcher::toString() const {
+    return u"<CodePoint>";
+}
+
+
+AffixPatternMatcher AffixPatternMatcher::fromAffixPattern(const UnicodeString& affixPattern,
+                                                          AffixTokenMatcherWarehouse& tokenWarehouse,
+                                                          parse_flags_t parseFlags, bool* success,
+                                                          UErrorCode& status) {
+    if (affixPattern.isEmpty()) {
+        *success = false;
+        return {};
+    }
+    *success = true;
+
+    IgnorablesMatcher* ignorables;
+    if (0 != (parseFlags & PARSE_FLAG_EXACT_AFFIX)) {
+        ignorables = nullptr;
+    } else {
+        ignorables = &tokenWarehouse.ignorables();
+    }
+
+    AffixPatternMatcherBuilder builder(affixPattern, tokenWarehouse, ignorables);
+    AffixUtils::iterateWithConsumer(affixPattern, builder, status);
+    return builder.build();
+}
+
+AffixPatternMatcher::AffixPatternMatcher(MatcherArray& matchers, int32_t matchersLen,
+                                         const UnicodeString& pattern)
+        : ArraySeriesMatcher(matchers, matchersLen), fPattern(pattern) {}
+
+UnicodeString AffixPatternMatcher::getPattern() const {
+    return fPattern.toAliasedUnicodeString();
+}
+
+bool AffixPatternMatcher::operator==(const AffixPatternMatcher& other) const {
+    return fPattern == other.fPattern;
+}
+
+
+AffixMatcherWarehouse::AffixMatcherWarehouse(AffixTokenMatcherWarehouse* tokenWarehouse)
+        : fTokenWarehouse(tokenWarehouse) {
+}
+
+bool AffixMatcherWarehouse::isInteresting(const AffixPatternProvider& patternInfo,
+                                          const IgnorablesMatcher& ignorables, parse_flags_t parseFlags,
+                                          UErrorCode& status) {
+    UnicodeString posPrefixString = patternInfo.getString(AffixPatternProvider::AFFIX_POS_PREFIX);
+    UnicodeString posSuffixString = patternInfo.getString(AffixPatternProvider::AFFIX_POS_SUFFIX);
+    UnicodeString negPrefixString;
+    UnicodeString negSuffixString;
+    if (patternInfo.hasNegativeSubpattern()) {
+        negPrefixString = patternInfo.getString(AffixPatternProvider::AFFIX_NEG_PREFIX);
+        negSuffixString = patternInfo.getString(AffixPatternProvider::AFFIX_NEG_SUFFIX);
+    }
+
+    if (0 == (parseFlags & PARSE_FLAG_USE_FULL_AFFIXES) &&
+        AffixUtils::containsOnlySymbolsAndIgnorables(posPrefixString, *ignorables.getSet(), status) &&
+        AffixUtils::containsOnlySymbolsAndIgnorables(posSuffixString, *ignorables.getSet(), status) &&
+        AffixUtils::containsOnlySymbolsAndIgnorables(negPrefixString, *ignorables.getSet(), status) &&
+        AffixUtils::containsOnlySymbolsAndIgnorables(negSuffixString, *ignorables.getSet(), status)
+        // HACK: Plus and minus sign are a special case: we accept them trailing only if they are
+        // trailing in the pattern string.
+        && !AffixUtils::containsType(posSuffixString, TYPE_PLUS_SIGN, status) &&
+        !AffixUtils::containsType(posSuffixString, TYPE_MINUS_SIGN, status) &&
+        !AffixUtils::containsType(negSuffixString, TYPE_PLUS_SIGN, status) &&
+        !AffixUtils::containsType(negSuffixString, TYPE_MINUS_SIGN, status)) {
+        // The affixes contain only symbols and ignorables.
+        // No need to generate affix matchers.
+        return false;
+    }
+    return true;
+}
+
+void AffixMatcherWarehouse::createAffixMatchers(const AffixPatternProvider& patternInfo,
+                                                MutableMatcherCollection& output,
+                                                const IgnorablesMatcher& ignorables,
+                                                parse_flags_t parseFlags, UErrorCode& status) {
+    if (!isInteresting(patternInfo, ignorables, parseFlags, status)) {
+        return;
+    }
+
+    // The affixes have interesting characters, or we are in strict mode.
+    // Use initial capacity of 6, the highest possible number of AffixMatchers.
+    UnicodeString sb;
+    bool includeUnpaired = 0 != (parseFlags & PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES);
+    UNumberSignDisplay signDisplay = (0 != (parseFlags & PARSE_FLAG_PLUS_SIGN_ALLOWED)) ? UNUM_SIGN_ALWAYS
+                                                                                        : UNUM_SIGN_AUTO;
+
+    int32_t numAffixMatchers = 0;
+    int32_t numAffixPatternMatchers = 0;
+
+    AffixPatternMatcher* posPrefix = nullptr;
+    AffixPatternMatcher* posSuffix = nullptr;
+
+    // Pre-process the affix strings to resolve LDML rules like sign display.
+    for (int8_t signum = 1; signum >= -1; signum--) {
+        // Generate Prefix
+        bool hasPrefix = false;
+        PatternStringUtils::patternInfoToStringBuilder(
+                patternInfo, true, signum, signDisplay, StandardPlural::OTHER, false, sb);
+        fAffixPatternMatchers[numAffixPatternMatchers] = AffixPatternMatcher::fromAffixPattern(
+                sb, *fTokenWarehouse, parseFlags, &hasPrefix, status);
+        AffixPatternMatcher* prefix = hasPrefix ? &fAffixPatternMatchers[numAffixPatternMatchers++]
+                                                : nullptr;
+
+        // Generate Suffix
+        bool hasSuffix = false;
+        PatternStringUtils::patternInfoToStringBuilder(
+                patternInfo, false, signum, signDisplay, StandardPlural::OTHER, false, sb);
+        fAffixPatternMatchers[numAffixPatternMatchers] = AffixPatternMatcher::fromAffixPattern(
+                sb, *fTokenWarehouse, parseFlags, &hasSuffix, status);
+        AffixPatternMatcher* suffix = hasSuffix ? &fAffixPatternMatchers[numAffixPatternMatchers++]
+                                                : nullptr;
+
+        if (signum == 1) {
+            posPrefix = prefix;
+            posSuffix = suffix;
+        } else if (equals(prefix, posPrefix) && equals(suffix, posSuffix)) {
+            // Skip adding these matchers (we already have equivalents)
+            continue;
+        }
+
+        // Flags for setting in the ParsedNumber; the token matchers may add more.
+        int flags = (signum == -1) ? FLAG_NEGATIVE : 0;
+
+        // Note: it is indeed possible for posPrefix and posSuffix to both be null.
+        // We still need to add that matcher for strict mode to work.
+        fAffixMatchers[numAffixMatchers++] = {prefix, suffix, flags};
+        if (includeUnpaired && prefix != nullptr && suffix != nullptr) {
+            // The following if statements are designed to prevent adding two identical matchers.
+            if (signum == 1 || !equals(prefix, posPrefix)) {
+                fAffixMatchers[numAffixMatchers++] = {prefix, nullptr, flags};
+            }
+            if (signum == 1 || !equals(suffix, posSuffix)) {
+                fAffixMatchers[numAffixMatchers++] = {nullptr, suffix, flags};
+            }
+        }
+    }
+
+    // Put the AffixMatchers in order, and then add them to the output.
+    // Since there are at most 9 elements, do a simple-to-implement bubble sort.
+    bool madeChanges;
+    do {
+        madeChanges = false;
+        for (int32_t i = 1; i < numAffixMatchers; i++) {
+            if (fAffixMatchers[i - 1].compareTo(fAffixMatchers[i]) > 0) {
+                madeChanges = true;
+                AffixMatcher temp = std::move(fAffixMatchers[i - 1]);
+                fAffixMatchers[i - 1] = std::move(fAffixMatchers[i]);
+                fAffixMatchers[i] = std::move(temp);
+            }
+        }
+    } while (madeChanges);
+
+    for (int32_t i = 0; i < numAffixMatchers; i++) {
+        // Enable the following line to debug affixes
+        //std::cout << "Adding affix matcher: " << CStr(fAffixMatchers[i].toString())() << std::endl;
+        output.addMatcher(fAffixMatchers[i]);
+    }
+}
+
+
+AffixMatcher::AffixMatcher(AffixPatternMatcher* prefix, AffixPatternMatcher* suffix, result_flags_t flags)
+        : fPrefix(prefix), fSuffix(suffix), fFlags(flags) {}
+
+bool AffixMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
+    if (!result.seenNumber()) {
+        // Prefix
+        // Do not match if:
+        // 1. We have already seen a prefix (result.prefix != null)
+        // 2. The prefix in this AffixMatcher is empty (prefix == null)
+        if (!result.prefix.isBogus() || fPrefix == nullptr) {
+            return false;
+        }
+
+        // Attempt to match the prefix.
+        int initialOffset = segment.getOffset();
+        bool maybeMore = fPrefix->match(segment, result, status);
+        if (initialOffset != segment.getOffset()) {
+            result.prefix = fPrefix->getPattern();
+        }
+        return maybeMore;
+
+    } else {
+        // Suffix
+        // Do not match if:
+        // 1. We have already seen a suffix (result.suffix != null)
+        // 2. The suffix in this AffixMatcher is empty (suffix == null)
+        // 3. The matched prefix does not equal this AffixMatcher's prefix
+        if (!result.suffix.isBogus() || fSuffix == nullptr || !matched(fPrefix, result.prefix)) {
+            return false;
+        }
+
+        // Attempt to match the suffix.
+        int initialOffset = segment.getOffset();
+        bool maybeMore = fSuffix->match(segment, result, status);
+        if (initialOffset != segment.getOffset()) {
+            result.suffix = fSuffix->getPattern();
+        }
+        return maybeMore;
+    }
+}
+
+bool AffixMatcher::smokeTest(const StringSegment& segment) const {
+    return (fPrefix != nullptr && fPrefix->smokeTest(segment)) ||
+           (fSuffix != nullptr && fSuffix->smokeTest(segment));
+}
+
+void AffixMatcher::postProcess(ParsedNumber& result) const {
+    // Check to see if our affix is the one that was matched. If so, set the flags in the result.
+    if (matched(fPrefix, result.prefix) && matched(fSuffix, result.suffix)) {
+        // Fill in the result prefix and suffix with non-null values (empty string).
+        // Used by strict mode to determine whether an entire affix pair was matched.
+        if (result.prefix.isBogus()) {
+            result.prefix = UnicodeString();
+        }
+        if (result.suffix.isBogus()) {
+            result.suffix = UnicodeString();
+        }
+        result.flags |= fFlags;
+        if (fPrefix != nullptr) {
+            fPrefix->postProcess(result);
+        }
+        if (fSuffix != nullptr) {
+            fSuffix->postProcess(result);
+        }
+    }
+}
+
+int8_t AffixMatcher::compareTo(const AffixMatcher& rhs) const {
+    const AffixMatcher& lhs = *this;
+    if (length(lhs.fPrefix) != length(rhs.fPrefix)) {
+        return length(lhs.fPrefix) > length(rhs.fPrefix) ? -1 : 1;
+    } else if (length(lhs.fSuffix) != length(rhs.fSuffix)) {
+        return length(lhs.fSuffix) > length(rhs.fSuffix) ? -1 : 1;
+    } else {
+        return 0;
+    }
+}
+
+UnicodeString AffixMatcher::toString() const {
+    bool isNegative = 0 != (fFlags & FLAG_NEGATIVE);
+    return UnicodeString(u"<Affix") + (isNegative ? u":negative " : u" ") +
+           (fPrefix ? fPrefix->getPattern() : u"null") + u"#" +
+           (fSuffix ? fSuffix->getPattern() : u"null") + u">";
+
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_affixes.h b/deps/icu-small/source/i18n/numparse_affixes.h
new file mode 100644
index 00000000000000..be8c4fb56473d1
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_affixes.h
@@ -0,0 +1,255 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_AFFIXES_H__
+#define __NUMPARSE_AFFIXES_H__
+
+#include "numparse_types.h"
+#include "numparse_symbols.h"
+#include "numparse_currency.h"
+#include "number_affixutils.h"
+#include "number_currencysymbols.h"
+
+#include <array>
+
+U_NAMESPACE_BEGIN
+namespace numparse {
+namespace impl {
+
+// Forward-declaration of implementation classes for friending
+class AffixPatternMatcherBuilder;
+class AffixPatternMatcher;
+
+using ::icu::number::impl::AffixPatternProvider;
+using ::icu::number::impl::TokenConsumer;
+using ::icu::number::impl::CurrencySymbols;
+
+
+class CodePointMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    CodePointMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    CodePointMatcher(UChar32 cp);
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    UnicodeString toString() const override;
+
+  private:
+    UChar32 fCp;
+};
+
+} // namespace impl
+} // namespace numparse
+
+// Export a explicit template instantiations of MaybeStackArray and CompactUnicodeString.
+// When building DLLs for Windows this is required even though no direct access leaks out of the i18n library.
+// (See digitlst.h, pluralaffix.h, datefmt.h, and others for similar examples.)
+// Note: These need to be outside of the impl::numparse namespace, or Clang will generate a compile error.
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<UChar, 4>;
+template class U_I18N_API MaybeStackArray<numparse::impl::CodePointMatcher*, 3>;
+template class U_I18N_API numparse::impl::CompactUnicodeString<4>;
+#endif
+
+namespace numparse {
+namespace impl {
+
+/**
+ * A warehouse to retain ownership of CodePointMatchers.
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API CodePointMatcherWarehouse : public UMemory {
+  private:
+    static constexpr int32_t CODE_POINT_STACK_CAPACITY = 5; // Number of entries directly on the stack
+    static constexpr int32_t CODE_POINT_BATCH_SIZE = 10; // Number of entries per heap allocation
+
+  public:
+    CodePointMatcherWarehouse();
+
+    // A custom destructor is needed to free the memory from MaybeStackArray.
+    // A custom move constructor and move assignment seem to be needed because of the custom destructor.
+
+    ~CodePointMatcherWarehouse();
+
+    CodePointMatcherWarehouse(CodePointMatcherWarehouse&& src) U_NOEXCEPT;
+
+    CodePointMatcherWarehouse& operator=(CodePointMatcherWarehouse&& src) U_NOEXCEPT;
+
+    NumberParseMatcher& nextCodePointMatcher(UChar32 cp);
+
+  private:
+    std::array<CodePointMatcher, CODE_POINT_STACK_CAPACITY> codePoints; // By value
+    MaybeStackArray<CodePointMatcher*, 3> codePointsOverflow; // On heap in "batches"
+    int32_t codePointCount; // Total for both the ones by value and on heap
+    int32_t codePointNumBatches; // Number of batches in codePointsOverflow
+};
+
+
+struct AffixTokenMatcherSetupData {
+    const CurrencySymbols& currencySymbols;
+    const DecimalFormatSymbols& dfs;
+    IgnorablesMatcher& ignorables;
+    const Locale& locale;
+    parse_flags_t parseFlags;
+};
+
+
+/**
+ * Small helper class that generates matchers for individual tokens for AffixPatternMatcher.
+ *
+ * In Java, this is called AffixTokenMatcherFactory (a "factory"). However, in C++, it is called a
+ * "warehouse", because in addition to generating the matchers, it also retains ownership of them. The
+ * warehouse must stay in scope for the whole lifespan of the AffixPatternMatcher that uses matchers from
+ * the warehouse.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API AffixTokenMatcherWarehouse : public UMemory {
+  public:
+    AffixTokenMatcherWarehouse() = default;  // WARNING: Leaves the object in an unusable state
+
+    AffixTokenMatcherWarehouse(const AffixTokenMatcherSetupData* setupData);
+
+    NumberParseMatcher& minusSign();
+
+    NumberParseMatcher& plusSign();
+
+    NumberParseMatcher& percent();
+
+    NumberParseMatcher& permille();
+
+    NumberParseMatcher& currency(UErrorCode& status);
+
+    IgnorablesMatcher& ignorables();
+
+    NumberParseMatcher& nextCodePointMatcher(UChar32 cp);
+
+  private:
+    // NOTE: The following field may be unsafe to access after construction is done!
+    const AffixTokenMatcherSetupData* fSetupData;
+
+    // NOTE: These are default-constructed and should not be used until initialized.
+    MinusSignMatcher fMinusSign;
+    PlusSignMatcher fPlusSign;
+    PercentMatcher fPercent;
+    PermilleMatcher fPermille;
+    CombinedCurrencyMatcher fCurrency;
+
+    // Use a child class for code point matchers, since it requires non-default operators.
+    CodePointMatcherWarehouse fCodePoints;
+
+    friend class AffixPatternMatcherBuilder;
+    friend class AffixPatternMatcher;
+};
+
+
+class AffixPatternMatcherBuilder : public TokenConsumer, public MutableMatcherCollection {
+  public:
+    AffixPatternMatcherBuilder(const UnicodeString& pattern, AffixTokenMatcherWarehouse& warehouse,
+                               IgnorablesMatcher* ignorables);
+
+    void consumeToken(::icu::number::impl::AffixPatternType type, UChar32 cp, UErrorCode& status) override;
+
+    /** NOTE: You can build only once! */
+    AffixPatternMatcher build();
+
+  private:
+    ArraySeriesMatcher::MatcherArray fMatchers;
+    int32_t fMatchersLen;
+    int32_t fLastTypeOrCp;
+
+    const UnicodeString& fPattern;
+    AffixTokenMatcherWarehouse& fWarehouse;
+    IgnorablesMatcher* fIgnorables;
+
+    void addMatcher(NumberParseMatcher& matcher) override;
+};
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API AffixPatternMatcher : public ArraySeriesMatcher {
+  public:
+    AffixPatternMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    static AffixPatternMatcher fromAffixPattern(const UnicodeString& affixPattern,
+                                                AffixTokenMatcherWarehouse& warehouse,
+                                                parse_flags_t parseFlags, bool* success,
+                                                UErrorCode& status);
+
+    UnicodeString getPattern() const;
+
+    bool operator==(const AffixPatternMatcher& other) const;
+
+  private:
+    CompactUnicodeString<4> fPattern;
+
+    AffixPatternMatcher(MatcherArray& matchers, int32_t matchersLen, const UnicodeString& pattern);
+
+    friend class AffixPatternMatcherBuilder;
+};
+
+
+class AffixMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    AffixMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    AffixMatcher(AffixPatternMatcher* prefix, AffixPatternMatcher* suffix, result_flags_t flags);
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    void postProcess(ParsedNumber& result) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    int8_t compareTo(const AffixMatcher& rhs) const;
+
+    UnicodeString toString() const override;
+
+  private:
+    AffixPatternMatcher* fPrefix;
+    AffixPatternMatcher* fSuffix;
+    result_flags_t fFlags;
+};
+
+
+/**
+ * A C++-only class to retain ownership of the AffixMatchers needed for parsing.
+ */
+class AffixMatcherWarehouse {
+  public:
+    AffixMatcherWarehouse() = default;  // WARNING: Leaves the object in an unusable state
+
+    AffixMatcherWarehouse(AffixTokenMatcherWarehouse* tokenWarehouse);
+
+    void createAffixMatchers(const AffixPatternProvider& patternInfo, MutableMatcherCollection& output,
+                             const IgnorablesMatcher& ignorables, parse_flags_t parseFlags,
+                             UErrorCode& status);
+
+  private:
+    // 9 is the limit: positive, zero, and negative, each with prefix, suffix, and prefix+suffix
+    AffixMatcher fAffixMatchers[9];
+    // 6 is the limit: positive, zero, and negative, a prefix and a suffix for each
+    AffixPatternMatcher fAffixPatternMatchers[6];
+    // Reference to the warehouse for tokens used by the AffixPatternMatchers
+    AffixTokenMatcherWarehouse* fTokenWarehouse;
+
+    friend class AffixMatcher;
+
+    static bool isInteresting(const AffixPatternProvider& patternInfo, const IgnorablesMatcher& ignorables,
+                              parse_flags_t parseFlags, UErrorCode& status);
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_AFFIXES_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_compositions.cpp b/deps/icu-small/source/i18n/numparse_compositions.cpp
new file mode 100644
index 00000000000000..19253da805f0bf
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_compositions.cpp
@@ -0,0 +1,107 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_compositions.h"
+#include "unicode/uniset.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+bool SeriesMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
+    ParsedNumber backup(result);
+
+    int32_t initialOffset = segment.getOffset();
+    bool maybeMore = true;
+    for (auto* it = begin(); it < end();) {
+        const NumberParseMatcher* matcher = *it;
+        int matcherOffset = segment.getOffset();
+        if (segment.length() != 0) {
+            maybeMore = matcher->match(segment, result, status);
+        } else {
+            // Nothing for this matcher to match; ask for more.
+            maybeMore = true;
+        }
+
+        bool success = (segment.getOffset() != matcherOffset);
+        bool isFlexible = matcher->isFlexible();
+        if (success && isFlexible) {
+            // Match succeeded, and this is a flexible matcher. Re-run it.
+        } else if (success) {
+            // Match succeeded, and this is NOT a flexible matcher. Proceed to the next matcher.
+            it++;
+            // Small hack: if there is another matcher coming, do not accept trailing weak chars.
+            // Needed for proper handling of currency spacing.
+            if (it < end() && segment.getOffset() != result.charEnd && result.charEnd > matcherOffset) {
+                segment.setOffset(result.charEnd);
+            }
+        } else if (isFlexible) {
+            // Match failed, and this is a flexible matcher. Try again with the next matcher.
+            it++;
+        } else {
+            // Match failed, and this is NOT a flexible matcher. Exit.
+            segment.setOffset(initialOffset);
+            result = backup;
+            return maybeMore;
+        }
+    }
+
+    // All matchers in the series succeeded.
+    return maybeMore;
+}
+
+bool SeriesMatcher::smokeTest(const StringSegment& segment) const {
+    // NOTE: The range-based for loop calls the virtual begin() and end() methods.
+    // NOTE: We only want the first element. Use the for loop for boundary checking.
+    for (auto& matcher : *this) {
+        // SeriesMatchers are never allowed to start with a Flexible matcher.
+        U_ASSERT(!matcher->isFlexible());
+        return matcher->smokeTest(segment);
+    }
+    return false;
+}
+
+void SeriesMatcher::postProcess(ParsedNumber& result) const {
+    // NOTE: The range-based for loop calls the virtual begin() and end() methods.
+    for (auto* matcher : *this) {
+        matcher->postProcess(result);
+    }
+}
+
+
+ArraySeriesMatcher::ArraySeriesMatcher()
+        : fMatchersLen(0) {
+}
+
+ArraySeriesMatcher::ArraySeriesMatcher(MatcherArray& matchers, int32_t matchersLen)
+        : fMatchers(std::move(matchers)), fMatchersLen(matchersLen) {
+}
+
+int32_t ArraySeriesMatcher::length() const {
+    return fMatchersLen;
+}
+
+const NumberParseMatcher* const* ArraySeriesMatcher::begin() const {
+    return fMatchers.getAlias();
+}
+
+const NumberParseMatcher* const* ArraySeriesMatcher::end() const {
+    return fMatchers.getAlias() + fMatchersLen;
+}
+
+UnicodeString ArraySeriesMatcher::toString() const {
+    return u"<ArraySeries>";
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_compositions.h b/deps/icu-small/source/i18n/numparse_compositions.h
new file mode 100644
index 00000000000000..f085912def1533
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_compositions.h
@@ -0,0 +1,124 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMPARSE_COMPOSITIONS__
+#define __SOURCE_NUMPARSE_COMPOSITIONS__
+
+#include "numparse_types.h"
+
+U_NAMESPACE_BEGIN
+
+// Export an explicit template instantiation of the MaybeStackArray that is used as a data member of ArraySeriesMatcher.
+// When building DLLs for Windows this is required even though no direct access to the MaybeStackArray leaks out of the i18n library.
+// (See digitlst.h, pluralaffix.h, datefmt.h, and others for similar examples.)
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<const numparse::impl::NumberParseMatcher*, 3>;
+#endif
+
+namespace numparse {
+namespace impl {
+
+/**
+ * Base class for AnyMatcher and SeriesMatcher.
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API CompositionMatcher : public NumberParseMatcher {
+  protected:
+    // No construction except by subclasses!
+    CompositionMatcher() = default;
+
+    // To be overridden by subclasses (used for iteration):
+    virtual const NumberParseMatcher* const* begin() const = 0;
+
+    // To be overridden by subclasses (used for iteration):
+    virtual const NumberParseMatcher* const* end() const = 0;
+};
+
+
+// NOTE: AnyMatcher is no longer being used. The previous definition is shown below.
+// The implementation can be found in SVN source control, deleted around March 30, 2018.
+///**
+// * Composes a number of matchers, and succeeds if any of the matchers succeed. Always greedily chooses
+// * the first matcher in the list to succeed.
+// *
+// * NOTE: In C++, this is a base class, unlike ICU4J, which uses a factory-style interface.
+// *
+// * @author sffc
+// * @see SeriesMatcher
+// */
+//class AnyMatcher : public CompositionMatcher {
+//  public:
+//    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+//
+//    bool smokeTest(const StringSegment& segment) const override;
+//
+//    void postProcess(ParsedNumber& result) const override;
+//
+//  protected:
+//    // No construction except by subclasses!
+//    AnyMatcher() = default;
+//};
+
+
+/**
+ * Composes a number of matchers, running one after another. Matches the input string only if all of the
+ * matchers in the series succeed. Performs greedy matches within the context of the series.
+ *
+ * @author sffc
+ * @see AnyMatcher
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API SeriesMatcher : public CompositionMatcher {
+  public:
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    void postProcess(ParsedNumber& result) const override;
+
+    virtual int32_t length() const = 0;
+
+  protected:
+    // No construction except by subclasses!
+    SeriesMatcher() = default;
+};
+
+/**
+ * An implementation of SeriesMatcher that references an array of matchers.
+ *
+ * The object adopts the array, but NOT the matchers contained inside the array.
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API ArraySeriesMatcher : public SeriesMatcher {
+  public:
+    ArraySeriesMatcher();  // WARNING: Leaves the object in an unusable state
+
+    typedef MaybeStackArray<const NumberParseMatcher*, 3> MatcherArray;
+
+    /** The array is std::move'd */
+    ArraySeriesMatcher(MatcherArray& matchers, int32_t matchersLen);
+
+    UnicodeString toString() const override;
+
+    int32_t length() const override;
+
+  protected:
+    const NumberParseMatcher* const* begin() const override;
+
+    const NumberParseMatcher* const* end() const override;
+
+  private:
+    MatcherArray fMatchers;
+    int32_t fMatchersLen;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMPARSE_COMPOSITIONS__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_currency.cpp b/deps/icu-small/source/i18n/numparse_currency.cpp
new file mode 100644
index 00000000000000..ae8196ec483799
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_currency.cpp
@@ -0,0 +1,186 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_currency.h"
+#include "ucurrimp.h"
+#include "unicode/errorcode.h"
+#include "numparse_utils.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+CombinedCurrencyMatcher::CombinedCurrencyMatcher(const CurrencySymbols& currencySymbols, const DecimalFormatSymbols& dfs,
+                                                 parse_flags_t parseFlags, UErrorCode& status)
+        : fCurrency1(currencySymbols.getCurrencySymbol(status)),
+          fCurrency2(currencySymbols.getIntlCurrencySymbol(status)),
+          fUseFullCurrencyData(0 == (parseFlags & PARSE_FLAG_NO_FOREIGN_CURRENCY)),
+          afterPrefixInsert(dfs.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, false, status)),
+          beforeSuffixInsert(dfs.getPatternForCurrencySpacing(UNUM_CURRENCY_INSERT, true, status)),
+          fLocaleName(dfs.getLocale().getName(), -1, status) {
+    utils::copyCurrencyCode(fCurrencyCode, currencySymbols.getIsoCode());
+
+    // Pre-load the long names for the current locale and currency
+    // if we are parsing without the full currency data.
+    if (!fUseFullCurrencyData) {
+        for (int32_t i=0; i<StandardPlural::COUNT; i++) {
+            auto plural = static_cast<StandardPlural::Form>(i);
+            fLocalLongNames[i] = currencySymbols.getPluralName(plural, status);
+        }
+    }
+
+    // TODO: Figure out how to make this faster and re-enable.
+    // Computing the "lead code points" set for fastpathing is too slow to use in production.
+    // See http://bugs.icu-project.org/trac/ticket/13584
+//    // Compute the full set of characters that could be the first in a currency to allow for
+//    // efficient smoke test.
+//    fLeadCodePoints.add(fCurrency1.char32At(0));
+//    fLeadCodePoints.add(fCurrency2.char32At(0));
+//    fLeadCodePoints.add(beforeSuffixInsert.char32At(0));
+//    uprv_currencyLeads(fLocaleName.data(), fLeadCodePoints, status);
+//    // Always apply case mapping closure for currencies
+//    fLeadCodePoints.closeOver(USET_ADD_CASE_MAPPINGS);
+//    fLeadCodePoints.freeze();
+}
+
+bool
+CombinedCurrencyMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
+    if (result.currencyCode[0] != 0) {
+        return false;
+    }
+
+    // Try to match a currency spacing separator.
+    int32_t initialOffset = segment.getOffset();
+    bool maybeMore = false;
+    if (result.seenNumber() && !beforeSuffixInsert.isEmpty()) {
+        int32_t overlap = segment.getCommonPrefixLength(beforeSuffixInsert);
+        if (overlap == beforeSuffixInsert.length()) {
+            segment.adjustOffset(overlap);
+            // Note: let currency spacing be a weak match. Don't update chars consumed.
+        }
+        maybeMore = maybeMore || overlap == segment.length();
+    }
+
+    // Match the currency string, and reset if we didn't find one.
+    maybeMore = maybeMore || matchCurrency(segment, result, status);
+    if (result.currencyCode[0] == 0) {
+        segment.setOffset(initialOffset);
+        return maybeMore;
+    }
+
+    // Try to match a currency spacing separator.
+    if (!result.seenNumber() && !afterPrefixInsert.isEmpty()) {
+        int32_t overlap = segment.getCommonPrefixLength(afterPrefixInsert);
+        if (overlap == afterPrefixInsert.length()) {
+            segment.adjustOffset(overlap);
+            // Note: let currency spacing be a weak match. Don't update chars consumed.
+        }
+        maybeMore = maybeMore || overlap == segment.length();
+    }
+
+    return maybeMore;
+}
+
+bool CombinedCurrencyMatcher::matchCurrency(StringSegment& segment, ParsedNumber& result,
+                                            UErrorCode& status) const {
+    bool maybeMore = false;
+
+    int32_t overlap1;
+    if (!fCurrency1.isEmpty()) {
+        overlap1 = segment.getCaseSensitivePrefixLength(fCurrency1);
+    } else {
+        overlap1 = -1;
+    }
+    maybeMore = maybeMore || overlap1 == segment.length();
+    if (overlap1 == fCurrency1.length()) {
+        utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
+        segment.adjustOffset(overlap1);
+        result.setCharsConsumed(segment);
+        return maybeMore;
+    }
+
+    int32_t overlap2;
+    if (!fCurrency2.isEmpty()) {
+        overlap2 = segment.getCaseSensitivePrefixLength(fCurrency2);
+    } else {
+        overlap2 = -1;
+    }
+    maybeMore = maybeMore || overlap2 == segment.length();
+    if (overlap2 == fCurrency2.length()) {
+        utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
+        segment.adjustOffset(overlap2);
+        result.setCharsConsumed(segment);
+        return maybeMore;
+    }
+
+    if (fUseFullCurrencyData) {
+        // Use the full currency data.
+        // NOTE: This call site should be improved with #13584.
+        const UnicodeString segmentString = segment.toTempUnicodeString();
+
+        // Try to parse the currency
+        ParsePosition ppos(0);
+        int32_t partialMatchLen = 0;
+        uprv_parseCurrency(
+                fLocaleName.data(),
+                segmentString,
+                ppos,
+                UCURR_SYMBOL_NAME, // checks for both UCURR_SYMBOL_NAME and UCURR_LONG_NAME
+                &partialMatchLen,
+                result.currencyCode,
+                status);
+        maybeMore = maybeMore || partialMatchLen == segment.length();
+
+        if (U_SUCCESS(status) && ppos.getIndex() != 0) {
+            // Complete match.
+            // NOTE: The currency code should already be saved in the ParsedNumber.
+            segment.adjustOffset(ppos.getIndex());
+            result.setCharsConsumed(segment);
+            return maybeMore;
+        }
+
+    } else {
+        // Use the locale long names.
+        int32_t longestFullMatch = 0;
+        for (int32_t i=0; i<StandardPlural::COUNT; i++) {
+            const UnicodeString& name = fLocalLongNames[i];
+            int32_t overlap = segment.getCommonPrefixLength(name);
+            if (overlap == name.length() && name.length() > longestFullMatch) {
+                longestFullMatch = name.length();
+            }
+            maybeMore = maybeMore || overlap > 0;
+        }
+        if (longestFullMatch > 0) {
+            utils::copyCurrencyCode(result.currencyCode, fCurrencyCode);
+            segment.adjustOffset(longestFullMatch);
+            result.setCharsConsumed(segment);
+            return maybeMore;
+        }
+    }
+
+    // No match found.
+    return maybeMore;
+}
+
+bool CombinedCurrencyMatcher::smokeTest(const StringSegment&) const {
+    // TODO: See constructor
+    return true;
+    //return segment.startsWith(fLeadCodePoints);
+}
+
+UnicodeString CombinedCurrencyMatcher::toString() const {
+    return u"<CombinedCurrencyMatcher>";
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_currency.h b/deps/icu-small/source/i18n/numparse_currency.h
new file mode 100644
index 00000000000000..a94943312fde9d
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_currency.h
@@ -0,0 +1,74 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_CURRENCY_H__
+#define __NUMPARSE_CURRENCY_H__
+
+#include "numparse_types.h"
+#include "numparse_compositions.h"
+#include "charstr.h"
+#include "number_currencysymbols.h"
+#include "unicode/uniset.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+using ::icu::number::impl::CurrencySymbols;
+
+/**
+ * Matches a currency, either a custom currency or one from the data bundle. The class is called
+ * "combined" to emphasize that the currency string may come from one of multiple sources.
+ *
+ * Will match currency spacing either before or after the number depending on whether we are currently in
+ * the prefix or suffix.
+ *
+ * The implementation of this class is slightly different between J and C. See #13584 for a follow-up.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API CombinedCurrencyMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    CombinedCurrencyMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    CombinedCurrencyMatcher(const CurrencySymbols& currencySymbols, const DecimalFormatSymbols& dfs,
+                            parse_flags_t parseFlags, UErrorCode& status);
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    UnicodeString toString() const override;
+
+  private:
+    UChar fCurrencyCode[4];
+    UnicodeString fCurrency1;
+    UnicodeString fCurrency2;
+
+    bool fUseFullCurrencyData;
+    UnicodeString fLocalLongNames[StandardPlural::COUNT];
+
+    UnicodeString afterPrefixInsert;
+    UnicodeString beforeSuffixInsert;
+
+    // We could use Locale instead of CharString here, but
+    // Locale has a non-trivial default constructor.
+    CharString fLocaleName;
+
+    // TODO: See comments in constructor in numparse_currency.cpp
+    // UnicodeSet fLeadCodePoints;
+
+    /** Matches the currency string without concern for currency spacing. */
+    bool matchCurrency(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_CURRENCY_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_decimal.cpp b/deps/icu-small/source/i18n/numparse_decimal.cpp
new file mode 100644
index 00000000000000..b120c5c6ad2f91
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_decimal.cpp
@@ -0,0 +1,458 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_decimal.h"
+#include "static_unicode_sets.h"
+#include "numparse_utils.h"
+#include "unicode/uchar.h"
+#include "putilimp.h"
+#include "number_decimalquantity.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+DecimalMatcher::DecimalMatcher(const DecimalFormatSymbols& symbols, const Grouper& grouper,
+                               parse_flags_t parseFlags) {
+    if (0 != (parseFlags & PARSE_FLAG_MONETARY_SEPARATORS)) {
+        groupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol);
+        decimalSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol);
+    } else {
+        groupingSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol);
+        decimalSeparator = symbols.getConstSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol);
+    }
+    bool strictSeparators = 0 != (parseFlags & PARSE_FLAG_STRICT_SEPARATORS);
+    unisets::Key groupingKey = strictSeparators ? unisets::STRICT_ALL_SEPARATORS
+                                                : unisets::ALL_SEPARATORS;
+
+    // Attempt to find separators in the static cache
+
+    groupingUniSet = unisets::get(groupingKey);
+    unisets::Key decimalKey = unisets::chooseFrom(
+            decimalSeparator,
+            strictSeparators ? unisets::STRICT_COMMA : unisets::COMMA,
+            strictSeparators ? unisets::STRICT_PERIOD : unisets::PERIOD);
+    if (decimalKey >= 0) {
+        decimalUniSet = unisets::get(decimalKey);
+    } else if (!decimalSeparator.isEmpty()) {
+        auto* set = new UnicodeSet();
+        set->add(decimalSeparator.char32At(0));
+        set->freeze();
+        decimalUniSet = set;
+        fLocalDecimalUniSet.adoptInstead(set);
+    } else {
+        decimalUniSet = unisets::get(unisets::EMPTY);
+    }
+
+    if (groupingKey >= 0 && decimalKey >= 0) {
+        // Everything is available in the static cache
+        separatorSet = groupingUniSet;
+        leadSet = unisets::get(
+                strictSeparators ? unisets::DIGITS_OR_ALL_SEPARATORS
+                                 : unisets::DIGITS_OR_STRICT_ALL_SEPARATORS);
+    } else {
+        auto* set = new UnicodeSet();
+        set->addAll(*groupingUniSet);
+        set->addAll(*decimalUniSet);
+        set->freeze();
+        separatorSet = set;
+        fLocalSeparatorSet.adoptInstead(set);
+        leadSet = nullptr;
+    }
+
+    UChar32 cpZero = symbols.getCodePointZero();
+    if (cpZero == -1 || !u_isdigit(cpZero) || u_digit(cpZero, 10) != 0) {
+        // Uncommon case: okay to allocate.
+        auto digitStrings = new UnicodeString[10];
+        fLocalDigitStrings.adoptInstead(digitStrings);
+        for (int32_t i = 0; i <= 9; i++) {
+            digitStrings[i] = symbols.getConstDigitSymbol(i);
+        }
+    }
+
+    requireGroupingMatch = 0 != (parseFlags & PARSE_FLAG_STRICT_GROUPING_SIZE);
+    groupingDisabled = 0 != (parseFlags & PARSE_FLAG_GROUPING_DISABLED);
+    integerOnly = 0 != (parseFlags & PARSE_FLAG_INTEGER_ONLY);
+    grouping1 = grouper.getPrimary();
+    grouping2 = grouper.getSecondary();
+
+    // Fraction grouping parsing is disabled for now but could be enabled later.
+    // See http://bugs.icu-project.org/trac/ticket/10794
+    // fractionGrouping = 0 != (parseFlags & PARSE_FLAG_FRACTION_GROUPING_ENABLED);
+}
+
+bool DecimalMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
+    return match(segment, result, 0, status);
+}
+
+bool DecimalMatcher::match(StringSegment& segment, ParsedNumber& result, int8_t exponentSign,
+                           UErrorCode&) const {
+    if (result.seenNumber() && exponentSign == 0) {
+        // A number has already been consumed.
+        return false;
+    } else if (exponentSign != 0) {
+        // scientific notation always comes after the number
+        U_ASSERT(!result.quantity.bogus);
+    }
+
+    // Initial offset before any character consumption.
+    int32_t initialOffset = segment.getOffset();
+
+    // Return value: whether to ask for more characters.
+    bool maybeMore = false;
+
+    // All digits consumed so far.
+    number::impl::DecimalQuantity digitsConsumed;
+    digitsConsumed.bogus = true;
+
+    // The total number of digits after the decimal place, used for scaling the result.
+    int32_t digitsAfterDecimalPlace = 0;
+
+    // The actual grouping and decimal separators used in the string.
+    // If non-null, we have seen that token.
+    UnicodeString actualGroupingString;
+    UnicodeString actualDecimalString;
+    actualGroupingString.setToBogus();
+    actualDecimalString.setToBogus();
+
+    // Information for two groups: the previous group and the current group.
+    //
+    // Each group has three pieces of information:
+    //
+    // Offset: the string position of the beginning of the group, including a leading separator
+    // if there was a leading separator. This is needed in case we need to rewind the parse to
+    // that position.
+    //
+    // Separator type:
+    // 0 => beginning of string
+    // 1 => lead separator is a grouping separator
+    // 2 => lead separator is a decimal separator
+    //
+    // Count: the number of digits in the group. If -1, the group has been validated.
+    int32_t currGroupOffset = 0;
+    int32_t currGroupSepType = 0;
+    int32_t currGroupCount = 0;
+    int32_t prevGroupOffset = -1;
+    int32_t prevGroupSepType = -1;
+    int32_t prevGroupCount = -1;
+
+    while (segment.length() > 0) {
+        maybeMore = false;
+
+        // Attempt to match a digit.
+        int8_t digit = -1;
+
+        // Try by code point digit value.
+        UChar32 cp = segment.getCodePoint();
+        if (u_isdigit(cp)) {
+            segment.adjustOffset(U16_LENGTH(cp));
+            digit = static_cast<int8_t>(u_digit(cp, 10));
+        }
+
+        // Try by digit string.
+        if (digit == -1 && !fLocalDigitStrings.isNull()) {
+            for (int32_t i = 0; i < 10; i++) {
+                const UnicodeString& str = fLocalDigitStrings[i];
+                if (str.isEmpty()) {
+                    continue;
+                }
+                int32_t overlap = segment.getCommonPrefixLength(str);
+                if (overlap == str.length()) {
+                    segment.adjustOffset(overlap);
+                    digit = static_cast<int8_t>(i);
+                    break;
+                }
+                maybeMore = maybeMore || (overlap == segment.length());
+            }
+        }
+
+        if (digit >= 0) {
+            // Digit was found.
+            if (digitsConsumed.bogus) {
+                digitsConsumed.bogus = false;
+                digitsConsumed.clear();
+            }
+            digitsConsumed.appendDigit(digit, 0, true);
+            currGroupCount++;
+            if (!actualDecimalString.isBogus()) {
+                digitsAfterDecimalPlace++;
+            }
+            continue;
+        }
+
+        // Attempt to match a literal grouping or decimal separator.
+        bool isDecimal = false;
+        bool isGrouping = false;
+
+        // 1) Attempt the decimal separator string literal.
+        // if (we have not seen a decimal separator yet) { ... }
+        if (actualDecimalString.isBogus() && !decimalSeparator.isEmpty()) {
+            int32_t overlap = segment.getCommonPrefixLength(decimalSeparator);
+            maybeMore = maybeMore || (overlap == segment.length());
+            if (overlap == decimalSeparator.length()) {
+                isDecimal = true;
+                actualDecimalString = decimalSeparator;
+            }
+        }
+
+        // 2) Attempt to match the actual grouping string literal.
+        if (!actualGroupingString.isBogus()) {
+            int32_t overlap = segment.getCommonPrefixLength(actualGroupingString);
+            maybeMore = maybeMore || (overlap == segment.length());
+            if (overlap == actualGroupingString.length()) {
+                isGrouping = true;
+            }
+        }
+
+        // 2.5) Attempt to match a new the grouping separator string literal.
+        // if (we have not seen a grouping or decimal separator yet) { ... }
+        if (!groupingDisabled && actualGroupingString.isBogus() && actualDecimalString.isBogus() &&
+            !groupingSeparator.isEmpty()) {
+            int32_t overlap = segment.getCommonPrefixLength(groupingSeparator);
+            maybeMore = maybeMore || (overlap == segment.length());
+            if (overlap == groupingSeparator.length()) {
+                isGrouping = true;
+                actualGroupingString = groupingSeparator;
+            }
+        }
+
+        // 3) Attempt to match a decimal separator from the equivalence set.
+        // if (we have not seen a decimal separator yet) { ... }
+        // The !isGrouping is to confirm that we haven't yet matched the current character.
+        if (!isGrouping && actualDecimalString.isBogus()) {
+            if (decimalUniSet->contains(cp)) {
+                isDecimal = true;
+                actualDecimalString = UnicodeString(cp);
+            }
+        }
+
+        // 4) Attempt to match a grouping separator from the equivalence set.
+        // if (we have not seen a grouping or decimal separator yet) { ... }
+        if (!groupingDisabled && actualGroupingString.isBogus() && actualDecimalString.isBogus()) {
+            if (groupingUniSet->contains(cp)) {
+                isGrouping = true;
+                actualGroupingString = UnicodeString(cp);
+            }
+        }
+
+        // Leave if we failed to match this as a separator.
+        if (!isDecimal && !isGrouping) {
+            break;
+        }
+
+        // Check for conditions when we don't want to accept the separator.
+        if (isDecimal && integerOnly) {
+            break;
+        } else if (currGroupSepType == 2 && isGrouping) {
+            // Fraction grouping
+            break;
+        }
+
+        // Validate intermediate grouping sizes.
+        bool prevValidSecondary = validateGroup(prevGroupSepType, prevGroupCount, false);
+        bool currValidPrimary = validateGroup(currGroupSepType, currGroupCount, true);
+        if (!prevValidSecondary || (isDecimal && !currValidPrimary)) {
+            // Invalid grouping sizes.
+            if (isGrouping && currGroupCount == 0) {
+                // Trailing grouping separators: these are taken care of below
+                U_ASSERT(currGroupSepType == 1);
+            } else if (requireGroupingMatch) {
+                // Strict mode: reject the parse
+                digitsConsumed.clear();
+                digitsConsumed.bogus = true;
+            }
+            break;
+        } else if (requireGroupingMatch && currGroupCount == 0 && currGroupSepType == 1) {
+            break;
+        } else {
+            // Grouping sizes OK so far.
+            prevGroupOffset = currGroupOffset;
+            prevGroupCount = currGroupCount;
+            if (isDecimal) {
+                // Do not validate this group any more.
+                prevGroupSepType = -1;
+            } else {
+                prevGroupSepType = currGroupSepType;
+            }
+        }
+
+        // OK to accept the separator.
+        // Special case: don't update currGroup if it is empty; this allows two grouping
+        // separators in a row in lenient mode.
+        if (currGroupCount != 0) {
+            currGroupOffset = segment.getOffset();
+        }
+        currGroupSepType = isGrouping ? 1 : 2;
+        currGroupCount = 0;
+        if (isGrouping) {
+            segment.adjustOffset(actualGroupingString.length());
+        } else {
+            segment.adjustOffset(actualDecimalString.length());
+        }
+    }
+
+    // End of main loop.
+    // Back up if there was a trailing grouping separator.
+    // Shift prev -> curr so we can check it as a final group.
+    if (currGroupSepType != 2 && currGroupCount == 0) {
+        maybeMore = true;
+        segment.setOffset(currGroupOffset);
+        currGroupOffset = prevGroupOffset;
+        currGroupSepType = prevGroupSepType;
+        currGroupCount = prevGroupCount;
+        prevGroupOffset = -1;
+        prevGroupSepType = 0;
+        prevGroupCount = 1;
+    }
+
+    // Validate final grouping sizes.
+    bool prevValidSecondary = validateGroup(prevGroupSepType, prevGroupCount, false);
+    bool currValidPrimary = validateGroup(currGroupSepType, currGroupCount, true);
+    if (!requireGroupingMatch) {
+        // The cases we need to handle here are lone digits.
+        // Examples: "1,1"  "1,1,"  "1,1,1"  "1,1,1,"  ",1" (all parse as 1)
+        // See more examples in numberformattestspecification.txt
+        int32_t digitsToRemove = 0;
+        if (!prevValidSecondary) {
+            segment.setOffset(prevGroupOffset);
+            digitsToRemove += prevGroupCount;
+            digitsToRemove += currGroupCount;
+        } else if (!currValidPrimary && (prevGroupSepType != 0 || prevGroupCount != 0)) {
+            maybeMore = true;
+            segment.setOffset(currGroupOffset);
+            digitsToRemove += currGroupCount;
+        }
+        if (digitsToRemove != 0) {
+            digitsConsumed.adjustMagnitude(-digitsToRemove);
+            digitsConsumed.truncate();
+        }
+        prevValidSecondary = true;
+        currValidPrimary = true;
+    }
+    if (currGroupSepType != 2 && (!prevValidSecondary || !currValidPrimary)) {
+        // Grouping failure.
+        digitsConsumed.bogus = true;
+    }
+
+    // Strings that start with a separator but have no digits,
+    // or strings that failed a grouping size check.
+    if (digitsConsumed.bogus) {
+        maybeMore = maybeMore || (segment.length() == 0);
+        segment.setOffset(initialOffset);
+        return maybeMore;
+    }
+
+    // We passed all inspections. Start post-processing.
+
+    // Adjust for fraction part.
+    digitsConsumed.adjustMagnitude(-digitsAfterDecimalPlace);
+
+    // Set the digits, either normal or exponent.
+    if (exponentSign != 0 && segment.getOffset() != initialOffset) {
+        bool overflow = false;
+        if (digitsConsumed.fitsInLong()) {
+            int64_t exponentLong = digitsConsumed.toLong(false);
+            U_ASSERT(exponentLong >= 0);
+            if (exponentLong <= INT32_MAX) {
+                auto exponentInt = static_cast<int32_t>(exponentLong);
+                if (result.quantity.adjustMagnitude(exponentSign * exponentInt)) {
+                    overflow = true;
+                }
+            } else {
+                overflow = true;
+            }
+        } else {
+            overflow = true;
+        }
+        if (overflow) {
+            if (exponentSign == -1) {
+                // Set to zero
+                result.quantity.clear();
+            } else {
+                // Set to infinity
+                result.quantity.bogus = true;
+                result.flags |= FLAG_INFINITY;
+            }
+        }
+    } else {
+        result.quantity = digitsConsumed;
+    }
+
+    // Set other information into the result and return.
+    if (!actualDecimalString.isBogus()) {
+        result.flags |= FLAG_HAS_DECIMAL_SEPARATOR;
+    }
+    result.setCharsConsumed(segment);
+    return segment.length() == 0 || maybeMore;
+}
+
+bool DecimalMatcher::validateGroup(int32_t sepType, int32_t count, bool isPrimary) const {
+    if (requireGroupingMatch) {
+        if (sepType == -1) {
+            // No such group (prevGroup before first shift).
+            return true;
+        } else if (sepType == 0) {
+            // First group.
+            if (isPrimary) {
+                // No grouping separators is OK.
+                return true;
+            } else {
+                return count != 0 && count <= grouping2;
+            }
+        } else if (sepType == 1) {
+            // Middle group.
+            if (isPrimary) {
+                return count == grouping1;
+            } else {
+                return count == grouping2;
+            }
+        } else {
+            U_ASSERT(sepType == 2);
+            // After the decimal separator.
+            return true;
+        }
+    } else {
+        if (sepType == 1) {
+            // #11230: don't accept middle groups with only 1 digit.
+            return count != 1;
+        } else {
+            return true;
+        }
+    }
+}
+
+bool DecimalMatcher::smokeTest(const StringSegment& segment) const {
+    // The common case uses a static leadSet for efficiency.
+    if (fLocalDigitStrings.isNull() && leadSet != nullptr) {
+        return segment.startsWith(*leadSet);
+    }
+    if (segment.startsWith(*separatorSet) || u_isdigit(segment.getCodePoint())) {
+        return true;
+    }
+    if (fLocalDigitStrings.isNull()) {
+        return false;
+    }
+    for (int32_t i = 0; i < 10; i++) {
+        if (segment.startsWith(fLocalDigitStrings[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+UnicodeString DecimalMatcher::toString() const {
+    return u"<Decimal>";
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_decimal.h b/deps/icu-small/source/i18n/numparse_decimal.h
new file mode 100644
index 00000000000000..ec6c76487e44fc
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_decimal.h
@@ -0,0 +1,76 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_DECIMAL_H__
+#define __NUMPARSE_DECIMAL_H__
+
+#include "unicode/uniset.h"
+#include "numparse_types.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+using ::icu::number::impl::Grouper;
+
+class DecimalMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    DecimalMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    DecimalMatcher(const DecimalFormatSymbols& symbols, const Grouper& grouper,
+                   parse_flags_t parseFlags);
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool
+    match(StringSegment& segment, ParsedNumber& result, int8_t exponentSign, UErrorCode& status) const;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    UnicodeString toString() const override;
+
+  private:
+    /** If true, only accept strings whose grouping sizes match the locale */
+    bool requireGroupingMatch;
+
+    /** If true, do not accept grouping separators at all */
+    bool groupingDisabled;
+
+    // Fraction grouping parsing is disabled for now but could be enabled later.
+    // See http://bugs.icu-project.org/trac/ticket/10794
+    // bool fractionGrouping;
+
+    /** If true, do not accept numbers in the fraction */
+    bool integerOnly;
+
+    int16_t grouping1;
+    int16_t grouping2;
+
+    UnicodeString groupingSeparator;
+    UnicodeString decimalSeparator;
+
+    // Assumption: these sets all consist of single code points. If this assumption needs to be broken,
+    // fix getLeadCodePoints() as well as matching logic. Be careful of the performance impact.
+    const UnicodeSet* groupingUniSet;
+    const UnicodeSet* decimalUniSet;
+    const UnicodeSet* separatorSet;
+    const UnicodeSet* leadSet;
+
+    // Make this class the owner of a few objects that could be allocated.
+    // The first three LocalPointers are used for assigning ownership only.
+    LocalPointer<const UnicodeSet> fLocalDecimalUniSet;
+    LocalPointer<const UnicodeSet> fLocalSeparatorSet;
+    LocalArray<const UnicodeString> fLocalDigitStrings;
+
+    bool validateGroup(int32_t sepType, int32_t count, bool isPrimary) const;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_DECIMAL_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_impl.cpp b/deps/icu-small/source/i18n/numparse_impl.cpp
new file mode 100644
index 00000000000000..5fa52f63351c31
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_impl.cpp
@@ -0,0 +1,361 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include <typeinfo>
+#include <array>
+#include "number_types.h"
+#include "number_patternstring.h"
+#include "numparse_types.h"
+#include "numparse_impl.h"
+#include "numparse_symbols.h"
+#include "numparse_decimal.h"
+#include "unicode/numberformatter.h"
+#include "cstr.h"
+#include "number_mapper.h"
+#include "static_unicode_sets.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+NumberParseMatcher::~NumberParseMatcher() = default;
+
+
+NumberParserImpl*
+NumberParserImpl::createSimpleParser(const Locale& locale, const UnicodeString& patternString,
+                                     parse_flags_t parseFlags, UErrorCode& status) {
+
+    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
+    DecimalFormatSymbols symbols(locale, status);
+
+    parser->fLocalMatchers.ignorables = {unisets::DEFAULT_IGNORABLES};
+    IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;
+
+    DecimalFormatSymbols dfs(locale, status);
+    dfs.setSymbol(DecimalFormatSymbols::kCurrencySymbol, u"IU$");
+    dfs.setSymbol(DecimalFormatSymbols::kIntlCurrencySymbol, u"ICU");
+    CurrencySymbols currencySymbols({u"ICU", status}, locale, dfs, status);
+
+    ParsedPatternInfo patternInfo;
+    PatternParser::parseToPatternInfo(patternString, patternInfo, status);
+
+    // The following statements set up the affix matchers.
+    AffixTokenMatcherSetupData affixSetupData = {
+            currencySymbols, symbols, ignorables, locale, parseFlags};
+    parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
+    parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
+    parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
+            patternInfo, *parser, ignorables, parseFlags, status);
+
+    Grouper grouper = Grouper::forStrategy(UNUM_GROUPING_AUTO);
+    grouper.setLocaleData(patternInfo, locale);
+
+    parser->addMatcher(parser->fLocalMatchers.ignorables);
+    parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
+    parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
+    parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
+    parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
+    parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
+    parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
+    parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
+    parser->addMatcher(parser->fLocalMatchers.padding = {u"@"});
+    parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
+    parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
+//    parser.addMatcher(new RequireNumberMatcher());
+
+    parser->freeze();
+    return parser.orphan();
+}
+
+NumberParserImpl*
+NumberParserImpl::createParserFromProperties(const number::impl::DecimalFormatProperties& properties,
+                                             const DecimalFormatSymbols& symbols, bool parseCurrency,
+                                             UErrorCode& status) {
+    Locale locale = symbols.getLocale();
+    PropertiesAffixPatternProvider localPAPP;
+    CurrencyPluralInfoAffixProvider localCPIAP;
+    AffixPatternProvider* affixProvider;
+    if (properties.currencyPluralInfo.fPtr.isNull()) {
+        localPAPP.setTo(properties, status);
+        affixProvider = &localPAPP;
+    } else {
+        localCPIAP.setTo(*properties.currencyPluralInfo.fPtr, properties, status);
+        affixProvider = &localCPIAP;
+    }
+    if (affixProvider == nullptr || U_FAILURE(status)) { return nullptr; }
+    CurrencyUnit currency = resolveCurrency(properties, locale, status);
+    CurrencySymbols currencySymbols(currency, locale, symbols, status);
+    bool isStrict = properties.parseMode.getOrDefault(PARSE_MODE_STRICT) == PARSE_MODE_STRICT;
+    Grouper grouper = Grouper::forProperties(properties);
+    int parseFlags = 0;
+    if (affixProvider == nullptr || U_FAILURE(status)) { return nullptr; }
+    if (!properties.parseCaseSensitive) {
+        parseFlags |= PARSE_FLAG_IGNORE_CASE;
+    }
+    if (properties.parseIntegerOnly) {
+        parseFlags |= PARSE_FLAG_INTEGER_ONLY;
+    }
+    if (properties.signAlwaysShown) {
+        parseFlags |= PARSE_FLAG_PLUS_SIGN_ALLOWED;
+    }
+    if (isStrict) {
+        parseFlags |= PARSE_FLAG_STRICT_GROUPING_SIZE;
+        parseFlags |= PARSE_FLAG_STRICT_SEPARATORS;
+        parseFlags |= PARSE_FLAG_USE_FULL_AFFIXES;
+        parseFlags |= PARSE_FLAG_EXACT_AFFIX;
+    } else {
+        parseFlags |= PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES;
+    }
+    if (grouper.getPrimary() <= 0) {
+        parseFlags |= PARSE_FLAG_GROUPING_DISABLED;
+    }
+    if (parseCurrency || affixProvider->hasCurrencySign()) {
+        parseFlags |= PARSE_FLAG_MONETARY_SEPARATORS;
+    }
+    if (!parseCurrency) {
+        parseFlags |= PARSE_FLAG_NO_FOREIGN_CURRENCY;
+    }
+
+    LocalPointer<NumberParserImpl> parser(new NumberParserImpl(parseFlags));
+
+    parser->fLocalMatchers.ignorables = {
+            isStrict ? unisets::STRICT_IGNORABLES : unisets::DEFAULT_IGNORABLES};
+    IgnorablesMatcher& ignorables = parser->fLocalMatchers.ignorables;
+
+    //////////////////////
+    /// AFFIX MATCHERS ///
+    //////////////////////
+
+    // The following statements set up the affix matchers.
+    AffixTokenMatcherSetupData affixSetupData = {
+            currencySymbols, symbols, ignorables, locale, parseFlags};
+    parser->fLocalMatchers.affixTokenMatcherWarehouse = {&affixSetupData};
+    parser->fLocalMatchers.affixMatcherWarehouse = {&parser->fLocalMatchers.affixTokenMatcherWarehouse};
+    parser->fLocalMatchers.affixMatcherWarehouse.createAffixMatchers(
+            *affixProvider, *parser, ignorables, parseFlags, status);
+
+    ////////////////////////
+    /// CURRENCY MATCHER ///
+    ////////////////////////
+
+    if (parseCurrency || affixProvider->hasCurrencySign()) {
+        parser->addMatcher(parser->fLocalMatchers.currency = {currencySymbols, symbols, parseFlags, status});
+    }
+
+    ///////////////
+    /// PERCENT ///
+    ///////////////
+
+    // ICU-TC meeting, April 11, 2018: accept percent/permille only if it is in the pattern,
+    // and to maintain regressive behavior, divide by 100 even if no percent sign is present.
+    if (affixProvider->containsSymbolType(AffixPatternType::TYPE_PERCENT, status)) {
+        parser->addMatcher(parser->fLocalMatchers.percent = {symbols});
+    }
+    if (affixProvider->containsSymbolType(AffixPatternType::TYPE_PERMILLE, status)) {
+        parser->addMatcher(parser->fLocalMatchers.permille = {symbols});
+    }
+
+    ///////////////////////////////
+    /// OTHER STANDARD MATCHERS ///
+    ///////////////////////////////
+
+    if (!isStrict) {
+        parser->addMatcher(parser->fLocalMatchers.plusSign = {symbols, false});
+        parser->addMatcher(parser->fLocalMatchers.minusSign = {symbols, false});
+    }
+    parser->addMatcher(parser->fLocalMatchers.nan = {symbols});
+    parser->addMatcher(parser->fLocalMatchers.infinity = {symbols});
+    UnicodeString padString = properties.padString;
+    if (!padString.isBogus() && !ignorables.getSet()->contains(padString)) {
+        parser->addMatcher(parser->fLocalMatchers.padding = {padString});
+    }
+    parser->addMatcher(parser->fLocalMatchers.ignorables);
+    parser->addMatcher(parser->fLocalMatchers.decimal = {symbols, grouper, parseFlags});
+    // NOTE: parseNoExponent doesn't disable scientific parsing if we have a scientific formatter
+    if (!properties.parseNoExponent || properties.minimumExponentDigits > 0) {
+        parser->addMatcher(parser->fLocalMatchers.scientific = {symbols, grouper});
+    }
+
+    //////////////////
+    /// VALIDATORS ///
+    //////////////////
+
+    parser->addMatcher(parser->fLocalValidators.number = {});
+    if (isStrict) {
+        parser->addMatcher(parser->fLocalValidators.affix = {});
+    }
+    if (parseCurrency) {
+        parser->addMatcher(parser->fLocalValidators.currency = {});
+    }
+    if (properties.decimalPatternMatchRequired) {
+        bool patternHasDecimalSeparator =
+                properties.decimalSeparatorAlwaysShown || properties.maximumFractionDigits != 0;
+        parser->addMatcher(parser->fLocalValidators.decimalSeparator = {patternHasDecimalSeparator});
+    }
+    // The multiplier takes care of scaling percentages.
+    Scale multiplier = scaleFromProperties(properties);
+    if (multiplier.isValid()) {
+        parser->addMatcher(parser->fLocalValidators.multiplier = {multiplier});
+    }
+
+    parser->freeze();
+    return parser.orphan();
+}
+
+NumberParserImpl::NumberParserImpl(parse_flags_t parseFlags)
+        : fParseFlags(parseFlags) {
+}
+
+NumberParserImpl::~NumberParserImpl() {
+    fNumMatchers = 0;
+}
+
+void NumberParserImpl::addMatcher(NumberParseMatcher& matcher) {
+    if (fNumMatchers + 1 > fMatchers.getCapacity()) {
+        fMatchers.resize(fNumMatchers * 2, fNumMatchers);
+    }
+    fMatchers[fNumMatchers] = &matcher;
+    fNumMatchers++;
+}
+
+void NumberParserImpl::freeze() {
+    fFrozen = true;
+}
+
+parse_flags_t NumberParserImpl::getParseFlags() const {
+    return fParseFlags;
+}
+
+void NumberParserImpl::parse(const UnicodeString& input, bool greedy, ParsedNumber& result,
+                             UErrorCode& status) const {
+    return parse(input, 0, greedy, result, status);
+}
+
+void NumberParserImpl::parse(const UnicodeString& input, int32_t start, bool greedy, ParsedNumber& result,
+                             UErrorCode& status) const {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    U_ASSERT(fFrozen);
+    // TODO: Check start >= 0 and start < input.length()
+    StringSegment segment(input, 0 != (fParseFlags & PARSE_FLAG_IGNORE_CASE));
+    segment.adjustOffset(start);
+    if (greedy) {
+        parseGreedyRecursive(segment, result, status);
+    } else {
+        parseLongestRecursive(segment, result, status);
+    }
+    for (int32_t i = 0; i < fNumMatchers; i++) {
+        fMatchers[i]->postProcess(result);
+    }
+    result.postProcess();
+}
+
+void NumberParserImpl::parseGreedyRecursive(StringSegment& segment, ParsedNumber& result,
+                                            UErrorCode& status) const {
+    // Base Case
+    if (segment.length() == 0) {
+        return;
+    }
+
+    int initialOffset = segment.getOffset();
+    for (int32_t i = 0; i < fNumMatchers; i++) {
+        const NumberParseMatcher* matcher = fMatchers[i];
+        if (!matcher->smokeTest(segment)) {
+            continue;
+        }
+        matcher->match(segment, result, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        if (segment.getOffset() != initialOffset) {
+            // In a greedy parse, recurse on only the first match.
+            parseGreedyRecursive(segment, result, status);
+            // The following line resets the offset so that the StringSegment says the same across
+            // the function
+            // call boundary. Since we recurse only once, this line is not strictly necessary.
+            segment.setOffset(initialOffset);
+            return;
+        }
+    }
+
+    // NOTE: If we get here, the greedy parse completed without consuming the entire string.
+}
+
+void NumberParserImpl::parseLongestRecursive(StringSegment& segment, ParsedNumber& result,
+                                             UErrorCode& status) const {
+    // Base Case
+    if (segment.length() == 0) {
+        return;
+    }
+
+    // TODO: Give a nice way for the matcher to reset the ParsedNumber?
+    ParsedNumber initial(result);
+    ParsedNumber candidate;
+
+    int initialOffset = segment.getOffset();
+    for (int32_t i = 0; i < fNumMatchers; i++) {
+        const NumberParseMatcher* matcher = fMatchers[i];
+        if (!matcher->smokeTest(segment)) {
+            continue;
+        }
+
+        // In a non-greedy parse, we attempt all possible matches and pick the best.
+        for (int32_t charsToConsume = 0; charsToConsume < segment.length();) {
+            charsToConsume += U16_LENGTH(segment.codePointAt(charsToConsume));
+
+            // Run the matcher on a segment of the current length.
+            candidate = initial;
+            segment.setLength(charsToConsume);
+            bool maybeMore = matcher->match(segment, candidate, status);
+            segment.resetLength();
+            if (U_FAILURE(status)) {
+                return;
+            }
+
+            // If the entire segment was consumed, recurse.
+            if (segment.getOffset() - initialOffset == charsToConsume) {
+                parseLongestRecursive(segment, candidate, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+                if (candidate.isBetterThan(result)) {
+                    result = candidate;
+                }
+            }
+
+            // Since the segment can be re-used, reset the offset.
+            // This does not have an effect if the matcher did not consume any chars.
+            segment.setOffset(initialOffset);
+
+            // Unless the matcher wants to see the next char, continue to the next matcher.
+            if (!maybeMore) {
+                break;
+            }
+        }
+    }
+}
+
+UnicodeString NumberParserImpl::toString() const {
+    UnicodeString result(u"<NumberParserImpl matchers:[");
+    for (int32_t i = 0; i < fNumMatchers; i++) {
+        result.append(u' ');
+        result.append(fMatchers[i]->toString());
+    }
+    result.append(u" ]>", -1);
+    return result;
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_impl.h b/deps/icu-small/source/i18n/numparse_impl.h
new file mode 100644
index 00000000000000..992114c7edee18
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_impl.h
@@ -0,0 +1,109 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_IMPL_H__
+#define __NUMPARSE_IMPL_H__
+
+#include "numparse_types.h"
+#include "numparse_decimal.h"
+#include "numparse_symbols.h"
+#include "numparse_scientific.h"
+#include "unicode/uniset.h"
+#include "numparse_currency.h"
+#include "numparse_affixes.h"
+#include "number_decimfmtprops.h"
+#include "unicode/localpointer.h"
+#include "numparse_validators.h"
+#include "number_multiplier.h"
+
+U_NAMESPACE_BEGIN
+
+// Export an explicit template instantiation of the MaybeStackArray that is used as a data member of NumberParserImpl.
+// When building DLLs for Windows this is required even though no direct access to the MaybeStackArray leaks out of the i18n library.
+// (See numparse_compositions.h, numparse_affixes.h, datefmt.h, and others for similar examples.)
+#if U_PF_WINDOWS <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
+template class U_I18N_API MaybeStackArray<const numparse::impl::NumberParseMatcher*, 10>;
+#endif
+
+namespace numparse {
+namespace impl {
+
+// Exported as U_I18N_API for tests
+class U_I18N_API NumberParserImpl : public MutableMatcherCollection, public UMemory {
+  public:
+    virtual ~NumberParserImpl();
+
+    static NumberParserImpl* createSimpleParser(const Locale& locale, const UnicodeString& patternString,
+                                                parse_flags_t parseFlags, UErrorCode& status);
+
+    static NumberParserImpl* createParserFromProperties(
+            const number::impl::DecimalFormatProperties& properties, const DecimalFormatSymbols& symbols,
+            bool parseCurrency, UErrorCode& status);
+
+    /**
+     * Does NOT take ownership of the matcher. The matcher MUST remain valid for the lifespan of the
+     * NumberParserImpl.
+     * @param matcher The matcher to reference.
+     */
+    void addMatcher(NumberParseMatcher& matcher) override;
+
+    void freeze();
+
+    parse_flags_t getParseFlags() const;
+
+    void parse(const UnicodeString& input, bool greedy, ParsedNumber& result, UErrorCode& status) const;
+
+    void parse(const UnicodeString& input, int32_t start, bool greedy, ParsedNumber& result,
+               UErrorCode& status) const;
+
+    UnicodeString toString() const;
+
+  private:
+    parse_flags_t fParseFlags;
+    int32_t fNumMatchers = 0;
+    // NOTE: The stack capacity for fMatchers and fLeads should be the same
+    MaybeStackArray<const NumberParseMatcher*, 10> fMatchers;
+    bool fFrozen = false;
+
+    // WARNING: All of these matchers start in an undefined state (default-constructed).
+    // You must use an assignment operator on them before using.
+    struct {
+        IgnorablesMatcher ignorables;
+        InfinityMatcher infinity;
+        MinusSignMatcher minusSign;
+        NanMatcher nan;
+        PaddingMatcher padding;
+        PercentMatcher percent;
+        PermilleMatcher permille;
+        PlusSignMatcher plusSign;
+        DecimalMatcher decimal;
+        ScientificMatcher scientific;
+        CombinedCurrencyMatcher currency;
+        AffixMatcherWarehouse affixMatcherWarehouse;
+        AffixTokenMatcherWarehouse affixTokenMatcherWarehouse;
+    } fLocalMatchers;
+    struct {
+        RequireAffixValidator affix;
+        RequireCurrencyValidator currency;
+        RequireDecimalSeparatorValidator decimalSeparator;
+        RequireNumberValidator number;
+        MultiplierParseHandler multiplier;
+    } fLocalValidators;
+
+    explicit NumberParserImpl(parse_flags_t parseFlags);
+
+    void parseGreedyRecursive(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const;
+
+    void parseLongestRecursive(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_IMPL_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_parsednumber.cpp b/deps/icu-small/source/i18n/numparse_parsednumber.cpp
new file mode 100644
index 00000000000000..98da4e8319227a
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_parsednumber.cpp
@@ -0,0 +1,122 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "number_decimalquantity.h"
+#include "putilimp.h"
+#include <cmath>
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+ParsedNumber::ParsedNumber() {
+    clear();
+}
+
+void ParsedNumber::clear() {
+    quantity.bogus = true;
+    charEnd = 0;
+    flags = 0;
+    prefix.setToBogus();
+    suffix.setToBogus();
+    currencyCode[0] = 0;
+}
+
+void ParsedNumber::setCharsConsumed(const StringSegment& segment) {
+    charEnd = segment.getOffset();
+}
+
+void ParsedNumber::postProcess() {
+    if (!quantity.bogus && 0 != (flags & FLAG_NEGATIVE)) {
+        quantity.negate();
+    }
+}
+
+bool ParsedNumber::success() const {
+    return charEnd > 0 && 0 == (flags & FLAG_FAIL);
+}
+
+bool ParsedNumber::seenNumber() const {
+    return !quantity.bogus || 0 != (flags & FLAG_NAN) || 0 != (flags & FLAG_INFINITY);
+}
+
+double ParsedNumber::getDouble() const {
+    bool sawNaN = 0 != (flags & FLAG_NAN);
+    bool sawInfinity = 0 != (flags & FLAG_INFINITY);
+
+    // Check for NaN, infinity, and -0.0
+    if (sawNaN) {
+        // Can't use NAN or std::nan because the byte pattern is platform-dependent;
+        // MSVC sets the sign bit, but Clang and GCC do not
+        return uprv_getNaN();
+    }
+    if (sawInfinity) {
+        if (0 != (flags & FLAG_NEGATIVE)) {
+            return -INFINITY;
+        } else {
+            return INFINITY;
+        }
+    }
+    U_ASSERT(!quantity.bogus);
+    if (quantity.isZero() && quantity.isNegative()) {
+        return -0.0;
+    }
+
+    if (quantity.fitsInLong()) {
+        return static_cast<double>(quantity.toLong());
+    } else {
+        return quantity.toDouble();
+    }
+}
+
+void ParsedNumber::populateFormattable(Formattable& output, parse_flags_t parseFlags) const {
+    bool sawNaN = 0 != (flags & FLAG_NAN);
+    bool sawInfinity = 0 != (flags & FLAG_INFINITY);
+    bool integerOnly = 0 != (parseFlags & PARSE_FLAG_INTEGER_ONLY);
+
+    // Check for NaN, infinity, and -0.0
+    if (sawNaN) {
+        // Can't use NAN or std::nan because the byte pattern is platform-dependent;
+        // MSVC sets the sign bit, but Clang and GCC do not
+        output.setDouble(uprv_getNaN());
+        return;
+    }
+    if (sawInfinity) {
+        if (0 != (flags & FLAG_NEGATIVE)) {
+            output.setDouble(-INFINITY);
+            return;
+        } else {
+            output.setDouble(INFINITY);
+            return;
+        }
+    }
+    U_ASSERT(!quantity.bogus);
+    if (quantity.isZero() && quantity.isNegative() && !integerOnly) {
+        output.setDouble(-0.0);
+        return;
+    }
+
+    // All other numbers
+    output.adoptDecimalQuantity(new DecimalQuantity(quantity));
+}
+
+bool ParsedNumber::isBetterThan(const ParsedNumber& other) {
+    // Favor results with strictly more characters consumed.
+    return charEnd > other.charEnd;
+}
+
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_scientific.cpp b/deps/icu-small/source/i18n/numparse_scientific.cpp
new file mode 100644
index 00000000000000..611695e57d4743
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_scientific.cpp
@@ -0,0 +1,133 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_scientific.h"
+#include "static_unicode_sets.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+namespace {
+
+inline const UnicodeSet& minusSignSet() {
+    return *unisets::get(unisets::MINUS_SIGN);
+}
+
+inline const UnicodeSet& plusSignSet() {
+    return *unisets::get(unisets::PLUS_SIGN);
+}
+
+} // namespace
+
+
+ScientificMatcher::ScientificMatcher(const DecimalFormatSymbols& dfs, const Grouper& grouper)
+        : fExponentSeparatorString(dfs.getConstSymbol(DecimalFormatSymbols::kExponentialSymbol)),
+          fExponentMatcher(dfs, grouper, PARSE_FLAG_INTEGER_ONLY | PARSE_FLAG_GROUPING_DISABLED) {
+
+    const UnicodeString& minusSign = dfs.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol);
+    if (minusSignSet().contains(minusSign)) {
+        fCustomMinusSign.setToBogus();
+    } else {
+        fCustomMinusSign = minusSign;
+    }
+
+    const UnicodeString& plusSign = dfs.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol);
+    if (plusSignSet().contains(plusSign)) {
+        fCustomPlusSign.setToBogus();
+    } else {
+        fCustomPlusSign = plusSign;
+    }
+}
+
+bool ScientificMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const {
+    // Only accept scientific notation after the mantissa.
+    if (!result.seenNumber()) {
+        return false;
+    }
+
+    // First match the scientific separator, and then match another number after it.
+    // NOTE: This is guarded by the smoke test; no need to check fExponentSeparatorString length again.
+    int overlap1 = segment.getCommonPrefixLength(fExponentSeparatorString);
+    if (overlap1 == fExponentSeparatorString.length()) {
+        // Full exponent separator match.
+
+        // First attempt to get a code point, returning true if we can't get one.
+        if (segment.length() == overlap1) {
+            return true;
+        }
+        segment.adjustOffset(overlap1);
+
+        // Allow a sign, and then try to match digits.
+        int8_t exponentSign = 1;
+        if (segment.startsWith(minusSignSet())) {
+            exponentSign = -1;
+            segment.adjustOffsetByCodePoint();
+        } else if (segment.startsWith(plusSignSet())) {
+            segment.adjustOffsetByCodePoint();
+        } else if (segment.startsWith(fCustomMinusSign)) {
+            // Note: call site is guarded with startsWith, which returns false on empty string
+            int32_t overlap2 = segment.getCommonPrefixLength(fCustomMinusSign);
+            if (overlap2 != fCustomMinusSign.length()) {
+                // Partial custom sign match; un-match the exponent separator.
+                segment.adjustOffset(-overlap1);
+                return true;
+            }
+            exponentSign = -1;
+            segment.adjustOffset(overlap2);
+        } else if (segment.startsWith(fCustomPlusSign)) {
+            // Note: call site is guarded with startsWith, which returns false on empty string
+            int32_t overlap2 = segment.getCommonPrefixLength(fCustomPlusSign);
+            if (overlap2 != fCustomPlusSign.length()) {
+                // Partial custom sign match; un-match the exponent separator.
+                segment.adjustOffset(-overlap1);
+                return true;
+            }
+            segment.adjustOffset(overlap2);
+        }
+
+        // We are supposed to accept E0 after NaN, so we need to make sure result.quantity is available.
+        bool wasBogus = result.quantity.bogus;
+        result.quantity.bogus = false;
+        int digitsOffset = segment.getOffset();
+        bool digitsReturnValue = fExponentMatcher.match(segment, result, exponentSign, status);
+        result.quantity.bogus = wasBogus;
+
+        if (segment.getOffset() != digitsOffset) {
+            // At least one exponent digit was matched.
+            result.flags |= FLAG_HAS_EXPONENT;
+        } else {
+            // No exponent digits were matched; un-match the exponent separator.
+            segment.adjustOffset(-overlap1);
+        }
+        return digitsReturnValue;
+
+    } else if (overlap1 == segment.length()) {
+        // Partial exponent separator match
+        return true;
+    }
+
+    // No match
+    return false;
+}
+
+bool ScientificMatcher::smokeTest(const StringSegment& segment) const {
+    return segment.startsWith(fExponentSeparatorString);
+}
+
+UnicodeString ScientificMatcher::toString() const {
+    return u"<Scientific>";
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_scientific.h b/deps/icu-small/source/i18n/numparse_scientific.h
new file mode 100644
index 00000000000000..ddecf858af3584
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_scientific.h
@@ -0,0 +1,45 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_SCIENTIFIC_H__
+#define __NUMPARSE_SCIENTIFIC_H__
+
+#include "numparse_types.h"
+#include "numparse_decimal.h"
+#include "unicode/numberformatter.h"
+
+using icu::number::impl::Grouper;
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+
+class ScientificMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    ScientificMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    ScientificMatcher(const DecimalFormatSymbols& dfs, const Grouper& grouper);
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    UnicodeString toString() const override;
+
+  private:
+    UnicodeString fExponentSeparatorString;
+    DecimalMatcher fExponentMatcher;
+    UnicodeString fCustomMinusSign;
+    UnicodeString fCustomPlusSign;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_SCIENTIFIC_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_stringsegment.cpp b/deps/icu-small/source/i18n/numparse_stringsegment.cpp
new file mode 100644
index 00000000000000..3db4fe618a603a
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_stringsegment.cpp
@@ -0,0 +1,146 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_stringsegment.h"
+#include "putilimp.h"
+#include "unicode/utf16.h"
+#include "unicode/uniset.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+StringSegment::StringSegment(const UnicodeString& str, bool ignoreCase)
+        : fStr(str), fStart(0), fEnd(str.length()),
+          fFoldCase(ignoreCase) {}
+
+int32_t StringSegment::getOffset() const {
+    return fStart;
+}
+
+void StringSegment::setOffset(int32_t start) {
+    fStart = start;
+}
+
+void StringSegment::adjustOffset(int32_t delta) {
+    fStart += delta;
+}
+
+void StringSegment::adjustOffsetByCodePoint() {
+    fStart += U16_LENGTH(getCodePoint());
+}
+
+void StringSegment::setLength(int32_t length) {
+    fEnd = fStart + length;
+}
+
+void StringSegment::resetLength() {
+    fEnd = fStr.length();
+}
+
+int32_t StringSegment::length() const {
+    return fEnd - fStart;
+}
+
+char16_t StringSegment::charAt(int32_t index) const {
+    return fStr.charAt(index + fStart);
+}
+
+UChar32 StringSegment::codePointAt(int32_t index) const {
+    return fStr.char32At(index + fStart);
+}
+
+UnicodeString StringSegment::toUnicodeString() const {
+    return UnicodeString(fStr.getBuffer() + fStart, fEnd - fStart);
+}
+
+const UnicodeString StringSegment::toTempUnicodeString() const {
+    // Use the readonly-aliasing constructor for efficiency.
+    return UnicodeString(FALSE, fStr.getBuffer() + fStart, fEnd - fStart);
+}
+
+UChar32 StringSegment::getCodePoint() const {
+    char16_t lead = fStr.charAt(fStart);
+    if (U16_IS_LEAD(lead) && fStart + 1 < fEnd) {
+        return fStr.char32At(fStart);
+    } else if (U16_IS_SURROGATE(lead)) {
+        return -1;
+    } else {
+        return lead;
+    }
+}
+
+bool StringSegment::startsWith(UChar32 otherCp) const {
+    return codePointsEqual(getCodePoint(), otherCp, fFoldCase);
+}
+
+bool StringSegment::startsWith(const UnicodeSet& uniset) const {
+    // TODO: Move UnicodeSet case-folding logic here.
+    // TODO: Handle string matches here instead of separately.
+    UChar32 cp = getCodePoint();
+    if (cp == -1) {
+        return false;
+    }
+    return uniset.contains(cp);
+}
+
+bool StringSegment::startsWith(const UnicodeString& other) const {
+    if (other.isBogus() || other.length() == 0 || length() == 0) {
+        return false;
+    }
+    int cp1 = getCodePoint();
+    int cp2 = other.char32At(0);
+    return codePointsEqual(cp1, cp2, fFoldCase);
+}
+
+int32_t StringSegment::getCommonPrefixLength(const UnicodeString& other) {
+    return getPrefixLengthInternal(other, fFoldCase);
+}
+
+int32_t StringSegment::getCaseSensitivePrefixLength(const UnicodeString& other) {
+    return getPrefixLengthInternal(other, false);
+}
+
+int32_t StringSegment::getPrefixLengthInternal(const UnicodeString& other, bool foldCase) {
+    U_ASSERT(other.length() > 0);
+    int32_t offset = 0;
+    for (; offset < uprv_min(length(), other.length());) {
+        // TODO: case-fold code points, not chars
+        char16_t c1 = charAt(offset);
+        char16_t c2 = other.charAt(offset);
+        if (!codePointsEqual(c1, c2, foldCase)) {
+            break;
+        }
+        offset++;
+    }
+    return offset;
+}
+
+bool StringSegment::codePointsEqual(UChar32 cp1, UChar32 cp2, bool foldCase) {
+    if (cp1 == cp2) {
+        return true;
+    }
+    if (!foldCase) {
+        return false;
+    }
+    cp1 = u_foldCase(cp1, TRUE);
+    cp2 = u_foldCase(cp2, TRUE);
+    return cp1 == cp2;
+}
+
+bool StringSegment::operator==(const UnicodeString& other) const {
+    return toTempUnicodeString() == other;
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_stringsegment.h b/deps/icu-small/source/i18n/numparse_stringsegment.h
new file mode 100644
index 00000000000000..7a84444d414889
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_stringsegment.h
@@ -0,0 +1,24 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_STRINGSEGMENT_H__
+#define __NUMPARSE_STRINGSEGMENT_H__
+
+#include "numparse_types.h"
+#include "number_types.h"
+#include "unicode/unistr.h"
+
+U_NAMESPACE_BEGIN
+namespace numparse {
+namespace impl {
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_STRINGSEGMENT_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_symbols.cpp b/deps/icu-small/source/i18n/numparse_symbols.cpp
new file mode 100644
index 00000000000000..9ccceec8475d01
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_symbols.cpp
@@ -0,0 +1,193 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_symbols.h"
+#include "numparse_utils.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+SymbolMatcher::SymbolMatcher(const UnicodeString& symbolString, unisets::Key key) {
+    fUniSet = unisets::get(key);
+    if (fUniSet->contains(symbolString)) {
+        fString.setToBogus();
+    } else {
+        fString = symbolString;
+    }
+}
+
+const UnicodeSet* SymbolMatcher::getSet() const {
+    return fUniSet;
+}
+
+bool SymbolMatcher::match(StringSegment& segment, ParsedNumber& result, UErrorCode&) const {
+    // Smoke test first; this matcher might be disabled.
+    if (isDisabled(result)) {
+        return false;
+    }
+
+    // Test the string first in order to consume trailing chars greedily.
+    int overlap = 0;
+    if (!fString.isEmpty()) {
+        overlap = segment.getCommonPrefixLength(fString);
+        if (overlap == fString.length()) {
+            segment.adjustOffset(fString.length());
+            accept(segment, result);
+            return false;
+        }
+    }
+
+    int cp = segment.getCodePoint();
+    if (cp != -1 && fUniSet->contains(cp)) {
+        segment.adjustOffset(U16_LENGTH(cp));
+        accept(segment, result);
+        return false;
+    }
+
+    return overlap == segment.length();
+}
+
+bool SymbolMatcher::smokeTest(const StringSegment& segment) const {
+    return segment.startsWith(*fUniSet) || segment.startsWith(fString);
+}
+
+UnicodeString SymbolMatcher::toString() const {
+    // TODO: Customize output for each symbol
+    return u"<Symbol>";
+}
+
+
+IgnorablesMatcher::IgnorablesMatcher(unisets::Key key)
+        : SymbolMatcher({}, key) {
+}
+
+bool IgnorablesMatcher::isFlexible() const {
+    return true;
+}
+
+UnicodeString IgnorablesMatcher::toString() const {
+    return u"<Ignorables>";
+}
+
+bool IgnorablesMatcher::isDisabled(const ParsedNumber&) const {
+    return false;
+}
+
+void IgnorablesMatcher::accept(StringSegment&, ParsedNumber&) const {
+    // No-op
+}
+
+
+InfinityMatcher::InfinityMatcher(const DecimalFormatSymbols& dfs)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kInfinitySymbol), unisets::INFINITY_KEY) {
+}
+
+bool InfinityMatcher::isDisabled(const ParsedNumber& result) const {
+    return 0 != (result.flags & FLAG_INFINITY);
+}
+
+void InfinityMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.flags |= FLAG_INFINITY;
+    result.setCharsConsumed(segment);
+}
+
+
+MinusSignMatcher::MinusSignMatcher(const DecimalFormatSymbols& dfs, bool allowTrailing)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kMinusSignSymbol), unisets::MINUS_SIGN),
+          fAllowTrailing(allowTrailing) {
+}
+
+bool MinusSignMatcher::isDisabled(const ParsedNumber& result) const {
+    return !fAllowTrailing && result.seenNumber();
+}
+
+void MinusSignMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.flags |= FLAG_NEGATIVE;
+    result.setCharsConsumed(segment);
+}
+
+
+NanMatcher::NanMatcher(const DecimalFormatSymbols& dfs)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kNaNSymbol), unisets::EMPTY) {
+}
+
+bool NanMatcher::isDisabled(const ParsedNumber& result) const {
+    return result.seenNumber();
+}
+
+void NanMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.flags |= FLAG_NAN;
+    result.setCharsConsumed(segment);
+}
+
+
+PaddingMatcher::PaddingMatcher(const UnicodeString& padString)
+        : SymbolMatcher(padString, unisets::EMPTY) {}
+
+bool PaddingMatcher::isFlexible() const {
+    return true;
+}
+
+bool PaddingMatcher::isDisabled(const ParsedNumber&) const {
+    return false;
+}
+
+void PaddingMatcher::accept(StringSegment&, ParsedNumber&) const {
+    // No-op
+}
+
+
+PercentMatcher::PercentMatcher(const DecimalFormatSymbols& dfs)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kPercentSymbol), unisets::PERCENT_SIGN) {
+}
+
+bool PercentMatcher::isDisabled(const ParsedNumber& result) const {
+    return 0 != (result.flags & FLAG_PERCENT);
+}
+
+void PercentMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.flags |= FLAG_PERCENT;
+    result.setCharsConsumed(segment);
+}
+
+
+PermilleMatcher::PermilleMatcher(const DecimalFormatSymbols& dfs)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kPerMillSymbol), unisets::PERMILLE_SIGN) {
+}
+
+bool PermilleMatcher::isDisabled(const ParsedNumber& result) const {
+    return 0 != (result.flags & FLAG_PERMILLE);
+}
+
+void PermilleMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.flags |= FLAG_PERMILLE;
+    result.setCharsConsumed(segment);
+}
+
+
+PlusSignMatcher::PlusSignMatcher(const DecimalFormatSymbols& dfs, bool allowTrailing)
+        : SymbolMatcher(dfs.getConstSymbol(DecimalFormatSymbols::kPlusSignSymbol), unisets::PLUS_SIGN),
+          fAllowTrailing(allowTrailing) {
+}
+
+bool PlusSignMatcher::isDisabled(const ParsedNumber& result) const {
+    return !fAllowTrailing && result.seenNumber();
+}
+
+void PlusSignMatcher::accept(StringSegment& segment, ParsedNumber& result) const {
+    result.setCharsConsumed(segment);
+}
+
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_symbols.h b/deps/icu-small/source/i18n/numparse_symbols.h
new file mode 100644
index 00000000000000..8912ee95b0d009
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_symbols.h
@@ -0,0 +1,173 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_SYMBOLS_H__
+#define __NUMPARSE_SYMBOLS_H__
+
+#include "numparse_types.h"
+#include "unicode/uniset.h"
+#include "static_unicode_sets.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+
+/**
+ * A base class for many matchers that performs a simple match against a UnicodeString and/or UnicodeSet.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API SymbolMatcher : public NumberParseMatcher, public UMemory {
+  public:
+    SymbolMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    const UnicodeSet* getSet() const;
+
+    bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const override;
+
+    bool smokeTest(const StringSegment& segment) const override;
+
+    UnicodeString toString() const override;
+
+    virtual bool isDisabled(const ParsedNumber& result) const = 0;
+
+    virtual void accept(StringSegment& segment, ParsedNumber& result) const = 0;
+
+  protected:
+    UnicodeString fString;
+    const UnicodeSet* fUniSet; // a reference from numparse_unisets.h; never owned
+
+    SymbolMatcher(const UnicodeString& symbolString, unisets::Key key);
+};
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API IgnorablesMatcher : public SymbolMatcher {
+  public:
+    IgnorablesMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    IgnorablesMatcher(unisets::Key key);
+
+    bool isFlexible() const override;
+
+    UnicodeString toString() const override;
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+
+class InfinityMatcher : public SymbolMatcher {
+  public:
+    InfinityMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    InfinityMatcher(const DecimalFormatSymbols& dfs);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API MinusSignMatcher : public SymbolMatcher {
+  public:
+    MinusSignMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    MinusSignMatcher(const DecimalFormatSymbols& dfs, bool allowTrailing);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+
+  private:
+    bool fAllowTrailing;
+};
+
+
+class NanMatcher : public SymbolMatcher {
+  public:
+    NanMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    NanMatcher(const DecimalFormatSymbols& dfs);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+
+class PaddingMatcher : public SymbolMatcher {
+  public:
+    PaddingMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    PaddingMatcher(const UnicodeString& padString);
+
+    bool isFlexible() const override;
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API PercentMatcher : public SymbolMatcher {
+  public:
+    PercentMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    PercentMatcher(const DecimalFormatSymbols& dfs);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+// Exported as U_I18N_API for tests
+class U_I18N_API PermilleMatcher : public SymbolMatcher {
+  public:
+    PermilleMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    PermilleMatcher(const DecimalFormatSymbols& dfs);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+};
+
+
+// Exported as U_I18N_API for tests
+class U_I18N_API PlusSignMatcher : public SymbolMatcher {
+  public:
+    PlusSignMatcher() = default;  // WARNING: Leaves the object in an unusable state
+
+    PlusSignMatcher(const DecimalFormatSymbols& dfs, bool allowTrailing);
+
+  protected:
+    bool isDisabled(const ParsedNumber& result) const override;
+
+    void accept(StringSegment& segment, ParsedNumber& result) const override;
+
+  private:
+    bool fAllowTrailing;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_SYMBOLS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_types.h b/deps/icu-small/source/i18n/numparse_types.h
new file mode 100644
index 00000000000000..ab591eaba83af5
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_types.h
@@ -0,0 +1,377 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_TYPES_H__
+#define __NUMPARSE_TYPES_H__
+
+#include "unicode/uobject.h"
+#include "number_decimalquantity.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+// Forward-declarations
+class StringSegment;
+class ParsedNumber;
+
+typedef int32_t result_flags_t;
+typedef int32_t parse_flags_t;
+
+/** Flags for the type result_flags_t */
+enum ResultFlags {
+    FLAG_NEGATIVE = 0x0001,
+    FLAG_PERCENT = 0x0002,
+    FLAG_PERMILLE = 0x0004,
+    FLAG_HAS_EXPONENT = 0x0008,
+    // FLAG_HAS_DEFAULT_CURRENCY = 0x0010, // no longer used
+    FLAG_HAS_DECIMAL_SEPARATOR = 0x0020,
+    FLAG_NAN = 0x0040,
+    FLAG_INFINITY = 0x0080,
+    FLAG_FAIL = 0x0100,
+};
+
+/** Flags for the type parse_flags_t */
+enum ParseFlags {
+    PARSE_FLAG_IGNORE_CASE = 0x0001,
+    PARSE_FLAG_MONETARY_SEPARATORS = 0x0002,
+    PARSE_FLAG_STRICT_SEPARATORS = 0x0004,
+    PARSE_FLAG_STRICT_GROUPING_SIZE = 0x0008,
+    PARSE_FLAG_INTEGER_ONLY = 0x0010,
+    PARSE_FLAG_GROUPING_DISABLED = 0x0020,
+    // PARSE_FLAG_FRACTION_GROUPING_ENABLED = 0x0040, // see #10794
+    PARSE_FLAG_INCLUDE_UNPAIRED_AFFIXES = 0x0080,
+    PARSE_FLAG_USE_FULL_AFFIXES = 0x0100,
+    PARSE_FLAG_EXACT_AFFIX = 0x0200,
+    PARSE_FLAG_PLUS_SIGN_ALLOWED = 0x0400,
+    // PARSE_FLAG_OPTIMIZE = 0x0800, // no longer used
+    // PARSE_FLAG_FORCE_BIG_DECIMAL = 0x1000, // not used in ICU4C
+    PARSE_FLAG_NO_FOREIGN_CURRENCY = 0x2000,
+};
+
+
+// TODO: Is this class worthwhile?
+template<int32_t stackCapacity>
+class CompactUnicodeString {
+  public:
+    CompactUnicodeString() {
+        static_assert(stackCapacity > 0, "cannot have zero space on stack");
+        fBuffer[0] = 0;
+    }
+
+    CompactUnicodeString(const UnicodeString& text)
+            : fBuffer(text.length() + 1) {
+        memcpy(fBuffer.getAlias(), text.getBuffer(), sizeof(UChar) * text.length());
+        fBuffer[text.length()] = 0;
+    }
+
+    inline UnicodeString toAliasedUnicodeString() const {
+        return UnicodeString(TRUE, fBuffer.getAlias(), -1);
+    }
+
+    bool operator==(const CompactUnicodeString& other) const {
+        // Use the alias-only constructor and then call UnicodeString operator==
+        return toAliasedUnicodeString() == other.toAliasedUnicodeString();
+    }
+
+  private:
+    MaybeStackArray<UChar, stackCapacity> fBuffer;
+};
+
+
+/**
+ * Struct-like class to hold the results of a parsing routine.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API ParsedNumber {
+  public:
+
+    /**
+     * The numerical value that was parsed.
+     */
+    ::icu::number::impl::DecimalQuantity quantity;
+
+    /**
+     * The index of the last char consumed during parsing. If parsing started at index 0, this is equal
+     * to the number of chars consumed. This is NOT necessarily the same as the StringSegment offset;
+     * "weak" chars, like whitespace, change the offset, but the charsConsumed is not touched until a
+     * "strong" char is encountered.
+     */
+    int32_t charEnd;
+
+    /**
+     * Boolean flags (see constants above).
+     */
+    result_flags_t flags;
+
+    /**
+     * The pattern string corresponding to the prefix that got consumed.
+     */
+    UnicodeString prefix;
+
+    /**
+     * The pattern string corresponding to the suffix that got consumed.
+     */
+    UnicodeString suffix;
+
+    /**
+     * The currency that got consumed.
+     */
+    UChar currencyCode[4];
+
+    ParsedNumber();
+
+    ParsedNumber(const ParsedNumber& other) = default;
+
+    ParsedNumber& operator=(const ParsedNumber& other) = default;
+
+    void clear();
+
+    /**
+     * Call this method to register that a "strong" char was consumed. This should be done after calling
+     * {@link StringSegment#setOffset} or {@link StringSegment#adjustOffset} except when the char is
+     * "weak", like whitespace.
+     *
+     * <p>
+     * <strong>What is a strong versus weak char?</strong> The behavior of number parsing is to "stop"
+     * after reading the number, even if there is other content following the number. For example, after
+     * parsing the string "123 " (123 followed by a space), the cursor should be set to 3, not 4, even
+     * though there are matchers that accept whitespace. In this example, the digits are strong, whereas
+     * the whitespace is weak. Grouping separators are weak, whereas decimal separators are strong. Most
+     * other chars are strong.
+     *
+     * @param segment
+     *            The current StringSegment, usually immediately following a call to setOffset.
+     */
+    void setCharsConsumed(const StringSegment& segment);
+
+    /** Apply certain number-related flags to the DecimalQuantity. */
+    void postProcess();
+
+    /**
+     * Returns whether this the parse was successful. To be successful, at least one char must have been
+     * consumed, and the failure flag must not be set.
+     */
+    bool success() const;
+
+    bool seenNumber() const;
+
+    double getDouble() const;
+
+    void populateFormattable(Formattable& output, parse_flags_t parseFlags) const;
+
+    bool isBetterThan(const ParsedNumber& other);
+};
+
+
+/**
+ * A mutable class allowing for a String with a variable offset and length. The charAt, length, and
+ * subSequence methods all operate relative to the fixed offset into the String.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API StringSegment : public UMemory {
+  public:
+    StringSegment(const UnicodeString& str, bool ignoreCase);
+
+    int32_t getOffset() const;
+
+    void setOffset(int32_t start);
+
+    /**
+     * Equivalent to <code>setOffset(getOffset()+delta)</code>.
+     *
+     * <p>
+     * This method is usually called by a Matcher to register that a char was consumed. If the char is
+     * strong (it usually is, except for things like whitespace), follow this with a call to
+     * {@link ParsedNumber#setCharsConsumed}. For more information on strong chars, see that method.
+     */
+    void adjustOffset(int32_t delta);
+
+    /**
+     * Adjusts the offset by the width of the current code point, either 1 or 2 chars.
+     */
+    void adjustOffsetByCodePoint();
+
+    void setLength(int32_t length);
+
+    void resetLength();
+
+    int32_t length() const;
+
+    char16_t charAt(int32_t index) const;
+
+    UChar32 codePointAt(int32_t index) const;
+
+    UnicodeString toUnicodeString() const;
+
+    const UnicodeString toTempUnicodeString() const;
+
+    /**
+     * Returns the first code point in the string segment, or -1 if the string starts with an invalid
+     * code point.
+     *
+     * <p>
+     * <strong>Important:</strong> Most of the time, you should use {@link #matches}, which handles case
+     * folding logic, instead of this method.
+     */
+    UChar32 getCodePoint() const;
+
+    /**
+     * Returns true if the first code point of this StringSegment equals the given code point.
+     *
+     * <p>
+     * This method will perform case folding if case folding is enabled for the parser.
+     */
+    bool startsWith(UChar32 otherCp) const;
+
+    /**
+     * Returns true if the first code point of this StringSegment is in the given UnicodeSet.
+     */
+    bool startsWith(const UnicodeSet& uniset) const;
+
+    /**
+     * Returns true if there is at least one code point of overlap between this StringSegment and the
+     * given UnicodeString.
+     */
+    bool startsWith(const UnicodeString& other) const;
+
+    /**
+     * Returns the length of the prefix shared by this StringSegment and the given CharSequence. For
+     * example, if this string segment is "aab", and the char sequence is "aac", this method returns 2,
+     * since the first 2 characters are the same.
+     *
+     * <p>
+     * This method only returns offsets along code point boundaries.
+     *
+     * <p>
+     * This method will perform case folding if case folding was enabled in the constructor.
+     *
+     * <p>
+     * IMPORTANT: The given UnicodeString must not be empty! It is the caller's responsibility to check.
+     */
+    int32_t getCommonPrefixLength(const UnicodeString& other);
+
+    /**
+     * Like {@link #getCommonPrefixLength}, but never performs case folding, even if case folding is
+     * enabled for the parser.
+     */
+    int32_t getCaseSensitivePrefixLength(const UnicodeString& other);
+
+    bool operator==(const UnicodeString& other) const;
+
+  private:
+    const UnicodeString fStr;
+    int32_t fStart;
+    int32_t fEnd;
+    bool fFoldCase;
+
+    int32_t getPrefixLengthInternal(const UnicodeString& other, bool foldCase);
+
+    static bool codePointsEqual(UChar32 cp1, UChar32 cp2, bool foldCase);
+};
+
+
+/**
+ * The core interface implemented by all matchers used for number parsing.
+ *
+ * Given a string, there should NOT be more than one way to consume the string with the same matcher
+ * applied multiple times. If there is, the non-greedy parsing algorithm will be unhappy and may enter an
+ * exponential-time loop. For example, consider the "A Matcher" that accepts "any number of As". Given
+ * the string "AAAA", there are 2^N = 8 ways to apply the A Matcher to this string: you could have the A
+ * Matcher apply 4 times to each character; you could have it apply just once to all the characters; you
+ * could have it apply to the first 2 characters and the second 2 characters; and so on. A better version
+ * of the "A Matcher" would be for it to accept exactly one A, and allow the algorithm to run it
+ * repeatedly to consume a string of multiple As. The A Matcher can implement the Flexible interface
+ * below to signal that it can be applied multiple times in a row.
+ *
+ * @author sffc
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API NumberParseMatcher {
+  public:
+    virtual ~NumberParseMatcher();
+
+    /**
+     * Matchers can override this method to return true to indicate that they are optional and can be run
+     * repeatedly. Used by SeriesMatcher, primarily in the context of IgnorablesMatcher.
+     */
+    virtual bool isFlexible() const {
+        return false;
+    }
+
+    /**
+     * Runs this matcher starting at the beginning of the given StringSegment. If this matcher finds
+     * something interesting in the StringSegment, it should update the offset of the StringSegment
+     * corresponding to how many chars were matched.
+     *
+     * This method is thread-safe.
+     *
+     * @param segment
+     *            The StringSegment to match against. Matches always start at the beginning of the
+     *            segment. The segment is guaranteed to contain at least one char.
+     * @param result
+     *            The data structure to store results if the match succeeds.
+     * @return Whether this matcher thinks there may be more interesting chars beyond the end of the
+     *         string segment.
+     */
+    virtual bool match(StringSegment& segment, ParsedNumber& result, UErrorCode& status) const = 0;
+
+    /**
+     * Performs a fast "smoke check" for whether or not this matcher could possibly match against the
+     * given string segment. The test should be as fast as possible but also as restrictive as possible.
+     * For example, matchers can maintain a UnicodeSet of all code points that count possibly start a
+     * match. Matchers should use the {@link StringSegment#startsWith} method in order to correctly
+     * handle case folding.
+     *
+     * @param segment
+     *            The segment to check against.
+     * @return true if the matcher might be able to match against this segment; false if it definitely
+     *         will not be able to match.
+     */
+    virtual bool smokeTest(const StringSegment& segment) const = 0;
+
+    /**
+     * Method called at the end of a parse, after all matchers have failed to consume any more chars.
+     * Allows a matcher to make final modifications to the result given the knowledge that no more
+     * matches are possible.
+     *
+     * @param result
+     *            The data structure to store results.
+     */
+    virtual void postProcess(ParsedNumber&) const {
+        // Default implementation: no-op
+    };
+
+    // String for debugging
+    virtual UnicodeString toString() const = 0;
+
+  protected:
+    // No construction except by subclasses!
+    NumberParseMatcher() = default;
+};
+
+
+/**
+ * Interface for use in arguments.
+ */
+// Exported as U_I18N_API for tests
+class U_I18N_API MutableMatcherCollection {
+  public:
+    virtual ~MutableMatcherCollection() = default;
+
+    virtual void addMatcher(NumberParseMatcher& matcher) = 0;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_TYPES_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_utils.h b/deps/icu-small/source/i18n/numparse_utils.h
new file mode 100644
index 00000000000000..162954bae09444
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_utils.h
@@ -0,0 +1,43 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __NUMPARSE_UTILS_H__
+#define __NUMPARSE_UTILS_H__
+
+#include "numparse_types.h"
+#include "unicode/uniset.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+namespace utils {
+
+
+inline static void putLeadCodePoints(const UnicodeSet* input, UnicodeSet* output) {
+    for (int32_t i = 0; i < input->getRangeCount(); i++) {
+        output->add(input->getRangeStart(i), input->getRangeEnd(i));
+    }
+    // TODO: ANDY: How to iterate over the strings in ICU4C UnicodeSet?
+}
+
+inline static void putLeadCodePoint(const UnicodeString& input, UnicodeSet* output) {
+    if (!input.isEmpty()) {
+        output->add(input.char32At(0));
+    }
+}
+
+inline static void copyCurrencyCode(UChar* dest, const UChar* src) {
+    uprv_memcpy(dest, src, sizeof(UChar) * 3);
+    dest[3] = 0;
+}
+
+
+} // namespace utils
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__NUMPARSE_UTILS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_validators.cpp b/deps/icu-small/source/i18n/numparse_validators.cpp
new file mode 100644
index 00000000000000..12d3465c4ef3a4
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_validators.cpp
@@ -0,0 +1,85 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+// Allow implicit conversion from char16_t* to UnicodeString for this file:
+// Helpful in toString methods and elsewhere.
+#define UNISTR_FROM_STRING_EXPLICIT
+
+#include "numparse_types.h"
+#include "numparse_validators.h"
+#include "static_unicode_sets.h"
+
+using namespace icu;
+using namespace icu::numparse;
+using namespace icu::numparse::impl;
+
+
+void RequireAffixValidator::postProcess(ParsedNumber& result) const {
+    if (result.prefix.isBogus() || result.suffix.isBogus()) {
+        // We saw a prefix or a suffix but not both. Fail the parse.
+        result.flags |= FLAG_FAIL;
+    }
+}
+
+UnicodeString RequireAffixValidator::toString() const {
+    return u"<ReqAffix>";
+}
+
+
+void RequireCurrencyValidator::postProcess(ParsedNumber& result) const {
+    if (result.currencyCode[0] == 0) {
+        result.flags |= FLAG_FAIL;
+    }
+}
+
+UnicodeString RequireCurrencyValidator::toString() const {
+    return u"<ReqCurrency>";
+}
+
+
+RequireDecimalSeparatorValidator::RequireDecimalSeparatorValidator(bool patternHasDecimalSeparator)
+        : fPatternHasDecimalSeparator(patternHasDecimalSeparator) {
+}
+
+void RequireDecimalSeparatorValidator::postProcess(ParsedNumber& result) const {
+    bool parseHasDecimalSeparator = 0 != (result.flags & FLAG_HAS_DECIMAL_SEPARATOR);
+    if (parseHasDecimalSeparator != fPatternHasDecimalSeparator) {
+        result.flags |= FLAG_FAIL;
+    }
+}
+
+UnicodeString RequireDecimalSeparatorValidator::toString() const {
+    return u"<ReqDecimal>";
+}
+
+
+void RequireNumberValidator::postProcess(ParsedNumber& result) const {
+    // Require that a number is matched.
+    if (!result.seenNumber()) {
+        result.flags |= FLAG_FAIL;
+    }
+}
+
+UnicodeString RequireNumberValidator::toString() const {
+    return u"<ReqNumber>";
+}
+
+MultiplierParseHandler::MultiplierParseHandler(::icu::number::Scale multiplier)
+        : fMultiplier(std::move(multiplier)) {}
+
+void MultiplierParseHandler::postProcess(ParsedNumber& result) const {
+    if (!result.quantity.bogus) {
+        fMultiplier.applyReciprocalTo(result.quantity);
+        // NOTE: It is okay if the multiplier was negative.
+    }
+}
+
+UnicodeString MultiplierParseHandler::toString() const {
+    return u"<Scale>";
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/numparse_validators.h b/deps/icu-small/source/i18n/numparse_validators.h
new file mode 100644
index 00000000000000..5d43b779d0bb67
--- /dev/null
+++ b/deps/icu-small/source/i18n/numparse_validators.h
@@ -0,0 +1,95 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __SOURCE_NUMPARSE_VALIDATORS_H__
+#define __SOURCE_NUMPARSE_VALIDATORS_H__
+
+#include "numparse_types.h"
+#include "static_unicode_sets.h"
+
+U_NAMESPACE_BEGIN namespace numparse {
+namespace impl {
+
+
+class ValidationMatcher : public NumberParseMatcher {
+  public:
+    bool match(StringSegment&, ParsedNumber&, UErrorCode&) const U_OVERRIDE {
+        // No-op
+        return false;
+    }
+
+    bool smokeTest(const StringSegment&) const U_OVERRIDE {
+        // No-op
+        return false;
+    }
+
+    void postProcess(ParsedNumber& result) const U_OVERRIDE = 0;
+};
+
+
+class RequireAffixValidator : public ValidationMatcher, public UMemory {
+  public:
+    void postProcess(ParsedNumber& result) const U_OVERRIDE;
+
+    UnicodeString toString() const U_OVERRIDE;
+};
+
+
+class RequireCurrencyValidator : public ValidationMatcher, public UMemory {
+  public:
+    void postProcess(ParsedNumber& result) const U_OVERRIDE;
+
+    UnicodeString toString() const U_OVERRIDE;
+};
+
+
+class RequireDecimalSeparatorValidator : public ValidationMatcher, public UMemory {
+  public:
+    RequireDecimalSeparatorValidator() = default;  // leaves instance in valid but undefined state
+
+    RequireDecimalSeparatorValidator(bool patternHasDecimalSeparator);
+
+    void postProcess(ParsedNumber& result) const U_OVERRIDE;
+
+    UnicodeString toString() const U_OVERRIDE;
+
+  private:
+    bool fPatternHasDecimalSeparator;
+};
+
+
+class RequireNumberValidator : public ValidationMatcher, public UMemory {
+  public:
+    void postProcess(ParsedNumber& result) const U_OVERRIDE;
+
+    UnicodeString toString() const U_OVERRIDE;
+};
+
+
+/**
+ * Wraps a {@link Multiplier} for use in the number parsing pipeline.
+ */
+class MultiplierParseHandler : public ValidationMatcher, public UMemory {
+  public:
+    MultiplierParseHandler() = default;  // leaves instance in valid but undefined state
+
+    MultiplierParseHandler(::icu::number::Scale multiplier);
+
+    void postProcess(ParsedNumber& result) const U_OVERRIDE;
+
+    UnicodeString toString() const U_OVERRIDE;
+
+  private:
+    ::icu::number::Scale fMultiplier;
+};
+
+
+} // namespace impl
+} // namespace numparse
+U_NAMESPACE_END
+
+#endif //__SOURCE_NUMPARSE_VALIDATORS_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/pluralaffix.cpp b/deps/icu-small/source/i18n/pluralaffix.cpp
deleted file mode 100644
index ea400206b38b81..00000000000000
--- a/deps/icu-small/source/i18n/pluralaffix.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: pluralaffix.cpp
- */
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "cstring.h"
-#include "digitaffix.h"
-#include "pluralaffix.h"
-
-U_NAMESPACE_BEGIN
-
-UBool
-PluralAffix::setVariant(
-        const char *variant, const UnicodeString &value, UErrorCode &status) {
-    DigitAffix *current = affixes.getMutable(variant, status);
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    current->remove();
-    current->append(value);
-    return TRUE;
-}
-
-void
-PluralAffix::remove() {
-    affixes.clear();
-}
-
-void
-PluralAffix::appendUChar(
-        const UChar value, int32_t fieldId) {
-    PluralMapBase::Category index = PluralMapBase::NONE;
-    for (DigitAffix *current = affixes.nextMutable(index);
-            current != NULL; current = affixes.nextMutable(index)) {
-        current->appendUChar(value, fieldId);
-    }
-}
-
-void
-PluralAffix::append(
-        const UnicodeString &value, int32_t fieldId) {
-    PluralMapBase::Category index = PluralMapBase::NONE;
-    for (DigitAffix *current = affixes.nextMutable(index);
-            current != NULL; current = affixes.nextMutable(index)) {
-        current->append(value, fieldId);
-    }
-}
-
-void
-PluralAffix::append(
-        const UChar *value, int32_t charCount, int32_t fieldId) {
-    PluralMapBase::Category index = PluralMapBase::NONE;
-    for (DigitAffix *current = affixes.nextMutable(index);
-            current != NULL; current = affixes.nextMutable(index)) {
-        current->append(value, charCount, fieldId);
-    }
-}
-
-UBool
-PluralAffix::append(
-        const PluralAffix &rhs, int32_t fieldId, UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    PluralMapBase::Category index = PluralMapBase::NONE;
-    while(rhs.affixes.next(index) != NULL) {
-        affixes.getMutableWithDefault(index, affixes.getOther(), status);
-    }
-    index = PluralMapBase::NONE;
-    for (DigitAffix *current = affixes.nextMutable(index);
-            current != NULL; current = affixes.nextMutable(index)) {
-        current->append(rhs.affixes.get(index).toString(), fieldId);
-    }
-    return TRUE;
-}
-
-const DigitAffix &
-PluralAffix::getByCategory(const char *category) const {
-    return affixes.get(category);
-}
-
-const DigitAffix &
-PluralAffix::getByCategory(const UnicodeString &category) const {
-    return affixes.get(category);
-}
-
-UBool
-PluralAffix::hasMultipleVariants() const {
-    // This works because OTHER is guaranteed to be the first enum value
-    PluralMapBase::Category index = PluralMapBase::OTHER;
-    return (affixes.next(index) != NULL);
-}
-
-U_NAMESPACE_END
-
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/pluralaffix.h b/deps/icu-small/source/i18n/pluralaffix.h
deleted file mode 100644
index 94366ce4cf81ec..00000000000000
--- a/deps/icu-small/source/i18n/pluralaffix.h
+++ /dev/null
@@ -1,177 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* pluralaffix.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __PLURALAFFIX_H__
-#define __PLURALAFFIX_H__
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/unum.h"
-#include "unicode/uobject.h"
-
-#include "digitaffix.h"
-#include "pluralmap.h"
-
-U_NAMESPACE_BEGIN
-
-class FieldPositionHandler;
-
-// Export an explicit template instantiation.
-//
-//    MSVC requires this, even though it should not be necessary.
-//    No direct access leaks out of the i18n library.
-//
-//    Macintosh produces duplicate definition linker errors with the explicit template
-//    instantiation.
-//
-#if !U_PLATFORM_IS_DARWIN_BASED
-template class U_I18N_API PluralMap<DigitAffix>;
-#endif
-
-
-/**
- * A plural aware prefix or suffix of a formatted number.
- *
- * PluralAffix is essentially a map of DigitAffix objects keyed by plural
- * category. The 'other' category is the default and always has some
- * value. The rest of the categories are optional. Querying for a category that
- * is not set always returns the DigitAffix stored in the 'other' category.
- *
- * To use one of these objects, build it up first using append() and
- * setVariant() methods. Once built, leave unchanged and let multiple threads
- * safely access.
- *
- * The following code is sample code for building up:
- *   one: US Dollar -
- *   other: US Dollars -
- *
- * and storing it in "negativeCurrencyPrefix"
- *
- * UErrorCode status = U_ZERO_ERROR;
- *
- * PluralAffix negativeCurrencyPrefix;
- *
- * PluralAffix currencyName;
- * currencyName.setVariant("one", "US Dollar", status);
- * currencyName.setVariant("other", "US Dollars", status);
- *
- * negativeCurrencyPrefix.append(currencyName, UNUM_CURRENCY_FIELD, status);
- * negativeCurrencyPrefix.append(" ");
- * negativeCurrencyPrefix.append("-", UNUM_SIGN_FIELD, status);
- */
-class U_I18N_API PluralAffix : public UMemory {
-public:
-
-    /**
-     * Create empty PluralAffix.
-     */
-    PluralAffix() : affixes() { }
-
-    /**
-     * Create a PluralAffix where the 'other' variant is otherVariant.
-     */
-    PluralAffix(const DigitAffix &otherVariant) : affixes(otherVariant) { }
-
-    /**
-     * Sets a particular variant for a plural category while overwriting
-     * anything that may have been previously stored for that plural
-     * category. The set value has no field annotations.
-     * @param category "one", "two", "few", ...
-     * @param variant the variant to store under the particular category
-     * @param status Any error returned here.
-     */
-    UBool setVariant(
-            const char *category,
-            const UnicodeString &variant,
-            UErrorCode &status);
-    /**
-     * Make the 'other' variant be the empty string with no field annotations
-     * and remove the variants for the rest of the plural categories.
-     */
-    void remove();
-
-    /**
-     * Append value to all set plural categories. If fieldId present, value
-     * is that field type.
-     */
-    void appendUChar(UChar value, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Append value to all set plural categories. If fieldId present, value
-     * is that field type.
-     */
-    void append(const UnicodeString &value, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Append value to all set plural categories. If fieldId present, value
-     * is that field type.
-     */
-    void append(const UChar *value, int32_t charCount, int32_t fieldId=UNUM_FIELD_COUNT);
-
-    /**
-     * Append the value for each plural category in rhs to the corresponding
-     * plural category in this instance. Each value appended from rhs is
-     * of type fieldId.
-     */
-    UBool append(
-            const PluralAffix &rhs,
-            int32_t fieldId,
-            UErrorCode &status);
-    /**
-     * Get the DigitAffix for a paricular category such as "zero", "one", ...
-     * If the particular category is not set, returns the 'other' category
-     * which is always set.
-     */
-    const DigitAffix &getByCategory(const char *category) const;
-
-    /**
-     * Get the DigitAffix for a paricular category such as "zero", "one", ...
-     * If the particular category is not set, returns the 'other' category
-     * which is always set.
-     */
-    const DigitAffix &getByCategory(const UnicodeString &category) const;
-
-    /**
-     * Get the DigitAffix for the other category which is always set.
-     */
-    const DigitAffix &getOtherVariant() const {
-        return affixes.getOther();
-    }
-
-    /**
-     * Returns TRUE if this instance has variants stored besides the "other"
-     * variant.
-     */
-    UBool hasMultipleVariants() const;
-
-    /**
-     * Returns TRUE if this instance equals rhs.
-     */
-    UBool equals(const PluralAffix &rhs) const {
-        return affixes.equals(rhs.affixes, &eq);
-    }
-
-private:
-    PluralMap<DigitAffix> affixes;
-
-    static UBool eq(const DigitAffix &x, const DigitAffix &y) {
-        return x.equals(y);
-    }
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif  // __PLURALAFFIX_H__
diff --git a/deps/icu-small/source/i18n/plurfmt.cpp b/deps/icu-small/source/i18n/plurfmt.cpp
index e14ef6d831ecce..2775766d32df80 100644
--- a/deps/icu-small/source/i18n/plurfmt.cpp
+++ b/deps/icu-small/source/i18n/plurfmt.cpp
@@ -21,13 +21,16 @@
 #include "plurrule_impl.h"
 #include "uassert.h"
 #include "uhash.h"
-#include "precision.h"
-#include "visibledigits.h"
+#include "number_decimalquantity.h"
+#include "number_utils.h"
+#include "number_utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 U_NAMESPACE_BEGIN
 
+using number::impl::DecimalQuantity;
+
 static const UChar OTHER_STRING[] = {
     0x6F, 0x74, 0x68, 0x65, 0x72, 0  // "other"
 };
@@ -258,45 +261,33 @@ PluralFormat::format(const Formattable& numberObject, double number,
     if (msgPattern.countParts() == 0) {
         return numberFormat->format(numberObject, appendTo, pos, status);
     }
+
     // Get the appropriate sub-message.
     // Select it based on the formatted number-offset.
     double numberMinusOffset = number - offset;
-    UnicodeString numberString;
-    FieldPosition ignorePos;
-    FixedPrecision fp;
-    VisibleDigitsWithExponent dec;
-    fp.initVisibleDigitsWithExponent(numberMinusOffset, dec, status);
-    if (U_FAILURE(status)) {
-        return appendTo;
-    }
+    // Call NumberFormatter to get both the DecimalQuantity and the string.
+    // This call site needs to use more internal APIs than the Java equivalent.
+    number::impl::UFormattedNumberData data;
     if (offset == 0) {
-        DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat);
-        if(decFmt != NULL) {
-            decFmt->initVisibleDigitsWithExponent(
-                    numberObject, dec, status);
-            if (U_FAILURE(status)) {
-                return appendTo;
-            }
-            decFmt->format(dec, numberString, ignorePos, status);
-        } else {
-            numberFormat->format(
-                    numberObject, numberString, ignorePos, status);  // could be BigDecimal etc.
-        }
+        // could be BigDecimal etc.
+        numberObject.populateDecimalQuantity(data.quantity, status);
     } else {
-        DecimalFormat *decFmt = dynamic_cast<DecimalFormat *>(numberFormat);
-        if(decFmt != NULL) {
-            decFmt->initVisibleDigitsWithExponent(
-                    numberMinusOffset, dec, status);
-            if (U_FAILURE(status)) {
-                return appendTo;
-            }
-            decFmt->format(dec, numberString, ignorePos, status);
+        data.quantity.setToDouble(numberMinusOffset);
+    }
+    UnicodeString numberString;
+    auto *decFmt = dynamic_cast<DecimalFormat *>(numberFormat);
+    if(decFmt != nullptr) {
+        decFmt->toNumberFormatter().formatImpl(&data, status); // mutates &data
+        numberString = data.string.toUnicodeString();
+    } else {
+        if (offset == 0) {
+            numberFormat->format(numberObject, numberString, status);
         } else {
-            numberFormat->format(
-                    numberMinusOffset, numberString, ignorePos, status);
+            numberFormat->format(numberMinusOffset, numberString, status);
         }
     }
-    int32_t partIndex = findSubMessage(msgPattern, 0, pluralRulesWrapper, &dec, number, status);
+
+    int32_t partIndex = findSubMessage(msgPattern, 0, pluralRulesWrapper, &data.quantity, number, status);
     if (U_FAILURE(status)) { return appendTo; }
     // Replace syntactic # signs in the top level of this sub-message
     // (not in nested arguments) with the formatted number-offset.
@@ -585,7 +576,7 @@ PluralFormat::PluralSelectorAdapter::~PluralSelectorAdapter() {
 UnicodeString PluralFormat::PluralSelectorAdapter::select(void *context, double number,
                                                           UErrorCode& /*ec*/) const {
     (void)number;  // unused except in the assertion
-    VisibleDigitsWithExponent *dec=static_cast<VisibleDigitsWithExponent *>(context);
+    IFixedDecimal *dec=static_cast<IFixedDecimal *>(context);
     return pluralRules->select(*dec);
 }
 
diff --git a/deps/icu-small/source/i18n/plurrule.cpp b/deps/icu-small/source/i18n/plurrule.cpp
index 6733a23e00362f..9597e8eb00d023 100644
--- a/deps/icu-small/source/i18n/plurrule.cpp
+++ b/deps/icu-small/source/i18n/plurrule.cpp
@@ -22,7 +22,6 @@
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
-#include "digitlst.h"
 #include "hash.h"
 #include "locutil.h"
 #include "mutex.h"
@@ -35,13 +34,15 @@
 #include "uvectr32.h"
 #include "sharedpluralrules.h"
 #include "unifiedcache.h"
-#include "digitinterval.h"
-#include "visibledigits.h"
+#include "number_decimalquantity.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 U_NAMESPACE_BEGIN
 
+using namespace icu::pluralimpl;
+using icu::number::impl::DecimalQuantity;
+
 static const UChar PLURAL_KEYWORD_OTHER[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,0};
 static const UChar PLURAL_DEFAULT_RULE[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,COLON,SPACE,LOW_N,0};
 static const UChar PK_IN[]={LOW_I,LOW_N,0};
@@ -247,26 +248,6 @@ PluralRules::select(double number) const {
     return select(FixedDecimal(number));
 }
 
-UnicodeString
-PluralRules::select(const Formattable& obj, const NumberFormat& fmt, UErrorCode& status) const {
-    if (U_SUCCESS(status)) {
-        const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(&fmt);
-        if (decFmt != NULL) {
-            VisibleDigitsWithExponent digits;
-            decFmt->initVisibleDigitsWithExponent(obj, digits, status);
-            if (U_SUCCESS(status)) {
-                return select(digits);
-            }
-        } else {
-            double number = obj.getDouble(status);
-            if (U_SUCCESS(status)) {
-                return select(number);
-            }
-        }
-    }
-    return UnicodeString();
-}
-
 UnicodeString
 PluralRules::select(const IFixedDecimal &number) const {
     if (mRules == NULL) {
@@ -277,14 +258,6 @@ PluralRules::select(const IFixedDecimal &number) const {
     }
 }
 
-UnicodeString
-PluralRules::select(const VisibleDigitsWithExponent &number) const {
-    if (number.getExponent() != NULL) {
-        return UnicodeString(TRUE, PLURAL_DEFAULT_RULE, -1);
-    }
-    return select(FixedDecimal(number.getMantissa()));
-}
-
 
 
 StringEnumeration*
@@ -1425,18 +1398,6 @@ PluralOperand tokenTypeToPluralOperand(tokenType tt) {
     }
 }
 
-IFixedDecimal::~IFixedDecimal() = default;
-
-FixedDecimal::FixedDecimal(const VisibleDigits &digits) {
-    digits.getFixedDecimal(
-            source, intValue, decimalDigits,
-            decimalDigitsWithoutTrailingZeros,
-            visibleDecimalDigitCount, hasIntegerValue);
-    isNegative = digits.isNegative();
-    _isNaN = digits.isNaN();
-    _isInfinite = digits.isInfinite();
-}
-
 FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f) {
     init(n, v, f);
     // check values. TODO make into unit test.
@@ -1474,14 +1435,14 @@ FixedDecimal::FixedDecimal() {
 FixedDecimal::FixedDecimal(const UnicodeString &num, UErrorCode &status) {
     CharString cs;
     cs.appendInvariantChars(num, status);
-    DigitList dl;
-    dl.set(cs.toStringPiece(), status);
+    DecimalQuantity dl;
+    dl.setToDecNumber(cs.toStringPiece(), status);
     if (U_FAILURE(status)) {
         init(0, 0, 0);
         return;
     }
     int32_t decimalPoint = num.indexOf(DOT);
-    double n = dl.getDouble();
+    double n = dl.toDouble();
     if (decimalPoint == -1) {
         init(n, 0, 0);
     } else {
@@ -1497,7 +1458,7 @@ FixedDecimal::FixedDecimal(const FixedDecimal &other) {
     decimalDigits = other.decimalDigits;
     decimalDigitsWithoutTrailingZeros = other.decimalDigitsWithoutTrailingZeros;
     intValue = other.intValue;
-    hasIntegerValue = other.hasIntegerValue;
+    _hasIntegerValue = other._hasIntegerValue;
     isNegative = other.isNegative;
     _isNaN = other._isNaN;
     _isInfinite = other._isInfinite;
@@ -1521,10 +1482,10 @@ void FixedDecimal::init(double n, int32_t v, int64_t f) {
         v = 0;
         f = 0;
         intValue = 0;
-        hasIntegerValue = FALSE;
+        _hasIntegerValue = FALSE;
     } else {
         intValue = (int64_t)source;
-        hasIntegerValue = (source == intValue);
+        _hasIntegerValue = (source == intValue);
     }
 
     visibleDecimalDigitCount = v;
@@ -1658,6 +1619,10 @@ bool FixedDecimal::isInfinite() const {
     return _isInfinite;
 }
 
+bool FixedDecimal::hasIntegerValue() const {
+    return _hasIntegerValue;
+}
+
 bool FixedDecimal::isNanOrInfinity() const {
     return _isNaN || _isInfinite;
 }
diff --git a/deps/icu-small/source/i18n/plurrule_impl.h b/deps/icu-small/source/i18n/plurrule_impl.h
index b93fc501baced2..3ab445d5843c8b 100644
--- a/deps/icu-small/source/i18n/plurrule_impl.h
+++ b/deps/icu-small/source/i18n/plurrule_impl.h
@@ -40,67 +40,73 @@ class DigitInterval;
 class PluralRules;
 class VisibleDigits;
 
-static const UChar DOT             = ((UChar)0x002E);
-static const UChar SINGLE_QUOTE    = ((UChar)0x0027);
-static const UChar SLASH           = ((UChar)0x002F);
-static const UChar BACKSLASH       = ((UChar)0x005C);
-static const UChar SPACE           = ((UChar)0x0020);
-static const UChar EXCLAMATION     = ((UChar)0x0021);
-static const UChar QUOTATION_MARK  = ((UChar)0x0022);
-static const UChar NUMBER_SIGN     = ((UChar)0x0023);
-static const UChar PERCENT_SIGN    = ((UChar)0x0025);
-static const UChar ASTERISK        = ((UChar)0x002A);
-static const UChar COMMA           = ((UChar)0x002C);
-static const UChar HYPHEN          = ((UChar)0x002D);
-static const UChar U_ZERO          = ((UChar)0x0030);
-static const UChar U_ONE           = ((UChar)0x0031);
-static const UChar U_TWO           = ((UChar)0x0032);
-static const UChar U_THREE         = ((UChar)0x0033);
-static const UChar U_FOUR          = ((UChar)0x0034);
-static const UChar U_FIVE          = ((UChar)0x0035);
-static const UChar U_SIX           = ((UChar)0x0036);
-static const UChar U_SEVEN         = ((UChar)0x0037);
-static const UChar U_EIGHT         = ((UChar)0x0038);
-static const UChar U_NINE          = ((UChar)0x0039);
-static const UChar COLON           = ((UChar)0x003A);
-static const UChar SEMI_COLON      = ((UChar)0x003B);
-static const UChar EQUALS          = ((UChar)0x003D);
-static const UChar AT              = ((UChar)0x0040);
-static const UChar CAP_A           = ((UChar)0x0041);
-static const UChar CAP_B           = ((UChar)0x0042);
-static const UChar CAP_R           = ((UChar)0x0052);
-static const UChar CAP_Z           = ((UChar)0x005A);
-static const UChar LOWLINE         = ((UChar)0x005F);
-static const UChar LEFTBRACE       = ((UChar)0x007B);
-static const UChar RIGHTBRACE      = ((UChar)0x007D);
-static const UChar TILDE           = ((UChar)0x007E);
-static const UChar ELLIPSIS        = ((UChar)0x2026);
-
-static const UChar LOW_A           = ((UChar)0x0061);
-static const UChar LOW_B           = ((UChar)0x0062);
-static const UChar LOW_C           = ((UChar)0x0063);
-static const UChar LOW_D           = ((UChar)0x0064);
-static const UChar LOW_E           = ((UChar)0x0065);
-static const UChar LOW_F           = ((UChar)0x0066);
-static const UChar LOW_G           = ((UChar)0x0067);
-static const UChar LOW_H           = ((UChar)0x0068);
-static const UChar LOW_I           = ((UChar)0x0069);
-static const UChar LOW_J           = ((UChar)0x006a);
-static const UChar LOW_K           = ((UChar)0x006B);
-static const UChar LOW_L           = ((UChar)0x006C);
-static const UChar LOW_M           = ((UChar)0x006D);
-static const UChar LOW_N           = ((UChar)0x006E);
-static const UChar LOW_O           = ((UChar)0x006F);
-static const UChar LOW_P           = ((UChar)0x0070);
-static const UChar LOW_Q           = ((UChar)0x0071);
-static const UChar LOW_R           = ((UChar)0x0072);
-static const UChar LOW_S           = ((UChar)0x0073);
-static const UChar LOW_T           = ((UChar)0x0074);
-static const UChar LOW_U           = ((UChar)0x0075);
-static const UChar LOW_V           = ((UChar)0x0076);
-static const UChar LOW_W           = ((UChar)0x0077);
-static const UChar LOW_Y           = ((UChar)0x0079);
-static const UChar LOW_Z           = ((UChar)0x007A);
+namespace pluralimpl {
+
+// TODO: Remove this and replace with u"" literals. Was for EBCDIC compatibility.
+
+static const UChar DOT = ((UChar) 0x002E);
+static const UChar SINGLE_QUOTE = ((UChar) 0x0027);
+static const UChar SLASH = ((UChar) 0x002F);
+static const UChar BACKSLASH = ((UChar) 0x005C);
+static const UChar SPACE = ((UChar) 0x0020);
+static const UChar EXCLAMATION = ((UChar) 0x0021);
+static const UChar QUOTATION_MARK = ((UChar) 0x0022);
+static const UChar NUMBER_SIGN = ((UChar) 0x0023);
+static const UChar PERCENT_SIGN = ((UChar) 0x0025);
+static const UChar ASTERISK = ((UChar) 0x002A);
+static const UChar COMMA = ((UChar) 0x002C);
+static const UChar HYPHEN = ((UChar) 0x002D);
+static const UChar U_ZERO = ((UChar) 0x0030);
+static const UChar U_ONE = ((UChar) 0x0031);
+static const UChar U_TWO = ((UChar) 0x0032);
+static const UChar U_THREE = ((UChar) 0x0033);
+static const UChar U_FOUR = ((UChar) 0x0034);
+static const UChar U_FIVE = ((UChar) 0x0035);
+static const UChar U_SIX = ((UChar) 0x0036);
+static const UChar U_SEVEN = ((UChar) 0x0037);
+static const UChar U_EIGHT = ((UChar) 0x0038);
+static const UChar U_NINE = ((UChar) 0x0039);
+static const UChar COLON = ((UChar) 0x003A);
+static const UChar SEMI_COLON = ((UChar) 0x003B);
+static const UChar EQUALS = ((UChar) 0x003D);
+static const UChar AT = ((UChar) 0x0040);
+static const UChar CAP_A = ((UChar) 0x0041);
+static const UChar CAP_B = ((UChar) 0x0042);
+static const UChar CAP_R = ((UChar) 0x0052);
+static const UChar CAP_Z = ((UChar) 0x005A);
+static const UChar LOWLINE = ((UChar) 0x005F);
+static const UChar LEFTBRACE = ((UChar) 0x007B);
+static const UChar RIGHTBRACE = ((UChar) 0x007D);
+static const UChar TILDE = ((UChar) 0x007E);
+static const UChar ELLIPSIS = ((UChar) 0x2026);
+
+static const UChar LOW_A = ((UChar) 0x0061);
+static const UChar LOW_B = ((UChar) 0x0062);
+static const UChar LOW_C = ((UChar) 0x0063);
+static const UChar LOW_D = ((UChar) 0x0064);
+static const UChar LOW_E = ((UChar) 0x0065);
+static const UChar LOW_F = ((UChar) 0x0066);
+static const UChar LOW_G = ((UChar) 0x0067);
+static const UChar LOW_H = ((UChar) 0x0068);
+static const UChar LOW_I = ((UChar) 0x0069);
+static const UChar LOW_J = ((UChar) 0x006a);
+static const UChar LOW_K = ((UChar) 0x006B);
+static const UChar LOW_L = ((UChar) 0x006C);
+static const UChar LOW_M = ((UChar) 0x006D);
+static const UChar LOW_N = ((UChar) 0x006E);
+static const UChar LOW_O = ((UChar) 0x006F);
+static const UChar LOW_P = ((UChar) 0x0070);
+static const UChar LOW_Q = ((UChar) 0x0071);
+static const UChar LOW_R = ((UChar) 0x0072);
+static const UChar LOW_S = ((UChar) 0x0073);
+static const UChar LOW_T = ((UChar) 0x0074);
+static const UChar LOW_U = ((UChar) 0x0075);
+static const UChar LOW_V = ((UChar) 0x0076);
+static const UChar LOW_W = ((UChar) 0x0077);
+static const UChar LOW_Y = ((UChar) 0x0079);
+static const UChar LOW_Z = ((UChar) 0x007A);
+
+}
 
 
 static const int32_t PLURAL_RANGE_HIGH = 0x7fffffff;
@@ -244,6 +250,9 @@ class U_I18N_API IFixedDecimal {
     virtual bool isNaN() const = 0;
 
     virtual bool isInfinite() const = 0;
+
+    /** Whether the number has no nonzero fraction digits. */
+    virtual bool hasIntegerValue() const = 0;
 };
 
 /**
@@ -263,7 +272,6 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
     FixedDecimal(double  n, int32_t v, int64_t f);
     FixedDecimal(double n, int32_t);
     explicit FixedDecimal(double n);
-    explicit FixedDecimal(const VisibleDigits &n);
     FixedDecimal();
     ~FixedDecimal() U_OVERRIDE;
     FixedDecimal(const UnicodeString &s, UErrorCode &ec);
@@ -272,6 +280,7 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
     double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
     bool isNaN() const U_OVERRIDE;
     bool isInfinite() const U_OVERRIDE;
+    bool hasIntegerValue() const U_OVERRIDE;
 
     bool isNanOrInfinity() const;  // used in decimfmtimpl.cpp
 
@@ -290,7 +299,7 @@ class U_I18N_API FixedDecimal: public IFixedDecimal, public UObject {
     int64_t     decimalDigits;
     int64_t     decimalDigitsWithoutTrailingZeros;
     int64_t     intValue;
-    UBool       hasIntegerValue;
+    UBool       _hasIntegerValue;
     UBool       isNegative;
     UBool       _isNaN;
     UBool       _isInfinite;
diff --git a/deps/icu-small/source/i18n/precision.cpp b/deps/icu-small/source/i18n/precision.cpp
deleted file mode 100644
index 97dc13dc385651..00000000000000
--- a/deps/icu-small/source/i18n/precision.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: precisison.cpp
- */
-
-#include <math.h>
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "digitlst.h"
-#include "fmtableimp.h"
-#include "precision.h"
-#include "putilimp.h"
-#include "visibledigits.h"
-
-U_NAMESPACE_BEGIN
-
-static const int32_t gPower10[] = {1, 10, 100, 1000};
-
-FixedPrecision::FixedPrecision()
-        : fExactOnly(FALSE), fFailIfOverMax(FALSE), fRoundingMode(DecimalFormat::kRoundHalfEven) {
-    fMin.setIntDigitCount(1);
-    fMin.setFracDigitCount(0);
-}
-
-UBool
-FixedPrecision::isRoundingRequired(
-        int32_t upperExponent, int32_t lowerExponent) const {
-    int32_t leastSigAllowed = fMax.getLeastSignificantInclusive();
-    int32_t maxSignificantDigits = fSignificant.getMax();
-    int32_t roundDigit;
-    if (maxSignificantDigits == INT32_MAX) {
-        roundDigit = leastSigAllowed;
-    } else {
-        int32_t limitDigit = upperExponent - maxSignificantDigits;
-        roundDigit =
-                limitDigit > leastSigAllowed ? limitDigit : leastSigAllowed;
-    }
-    return (roundDigit > lowerExponent);
-}
-
-DigitList &
-FixedPrecision::round(
-        DigitList &value, int32_t exponent, UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return value;
-    }
-    value .fContext.status &= ~DEC_Inexact;
-    if (!fRoundingIncrement.isZero()) {
-        if (exponent == 0) {
-            value.quantize(fRoundingIncrement, status);
-        } else {
-            DigitList adjustedIncrement(fRoundingIncrement);
-            adjustedIncrement.shiftDecimalRight(exponent);
-            value.quantize(adjustedIncrement, status);
-        }
-        if (U_FAILURE(status)) {
-            return value;
-        }
-    }
-    int32_t leastSig = fMax.getLeastSignificantInclusive();
-    if (leastSig == INT32_MIN) {
-        value.round(fSignificant.getMax());
-    } else {
-        value.roundAtExponent(
-                exponent + leastSig,
-                fSignificant.getMax());
-    }
-    if (fExactOnly && (value.fContext.status & DEC_Inexact)) {
-        status = U_FORMAT_INEXACT_ERROR;
-    } else if (fFailIfOverMax) {
-        // Smallest interval for value stored in interval
-        DigitInterval interval;
-        value.getSmallestInterval(interval);
-        if (fMax.getIntDigitCount() < interval.getIntDigitCount()) {
-            status = U_ILLEGAL_ARGUMENT_ERROR;
-        }
-    }
-    return value;
-}
-
-DigitInterval &
-FixedPrecision::getIntervalForZero(DigitInterval &interval) const {
-    interval = fMin;
-    if (fSignificant.getMin() > 0) {
-        interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin());
-    }
-    interval.shrinkToFitWithin(fMax);
-    return interval;
-}
-
-DigitInterval &
-FixedPrecision::getInterval(
-        int32_t upperExponent, DigitInterval &interval) const {
-    if (fSignificant.getMin() > 0) {
-        interval.expandToContainDigit(
-                upperExponent - fSignificant.getMin());
-    }
-    interval.expandToContain(fMin);
-    interval.shrinkToFitWithin(fMax);
-    return interval;
-}
-
-DigitInterval &
-FixedPrecision::getInterval(
-        const DigitList &value, DigitInterval &interval) const {
-    if (value.isZero()) {
-        interval = fMin;
-        if (fSignificant.getMin() > 0) {
-            interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin());
-        }
-    } else {
-        value.getSmallestInterval(interval);
-        if (fSignificant.getMin() > 0) {
-            interval.expandToContainDigit(
-                    value.getUpperExponent() - fSignificant.getMin());
-        }
-        interval.expandToContain(fMin);
-    }
-    interval.shrinkToFitWithin(fMax);
-    return interval;
-}
-
-UBool
-FixedPrecision::isFastFormattable() const {
-    return (fMin.getFracDigitCount() == 0 && fSignificant.isNoConstraints() && fRoundingIncrement.isZero() && !fFailIfOverMax);
-}
-
-UBool
-FixedPrecision::handleNonNumeric(DigitList &value, VisibleDigits &digits) {
-    if (value.isNaN()) {
-        digits.setNaN();
-        return TRUE;
-    }
-    if (value.isInfinite()) {
-        digits.setInfinite();
-        if (!value.isPositive()) {
-            digits.setNegative();
-        }
-        return TRUE;
-    }
-    return FALSE;
-}
-
-VisibleDigits &
-FixedPrecision::initVisibleDigits(
-        DigitList &value,
-        VisibleDigits &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    digits.clear();
-    if (handleNonNumeric(value, digits)) {
-        return digits;
-    }
-    if (!value.isPositive()) {
-        digits.setNegative();
-    }
-    value.setRoundingMode(fRoundingMode);
-    round(value, 0, status);
-    getInterval(value, digits.fInterval);
-    digits.fExponent = value.getLowerExponent();
-    value.appendDigitsTo(digits.fDigits, status);
-    return digits;
-}
-
-VisibleDigits &
-FixedPrecision::initVisibleDigits(
-        int64_t value,
-        VisibleDigits &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    if (!fRoundingIncrement.isZero()) {
-        // If we have round increment, use digit list.
-        DigitList digitList;
-        digitList.set(value);
-        return initVisibleDigits(digitList, digits, status);
-    }
-    // Try fast path
-    if (initVisibleDigits(value, 0, digits, status)) {
-        digits.fAbsDoubleValue = fabs((double) value);
-        digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits();
-        return digits;
-    }
-    // Oops have to use digit list
-    DigitList digitList;
-    digitList.set(value);
-    return initVisibleDigits(digitList, digits, status);
-}
-
-VisibleDigits &
-FixedPrecision::initVisibleDigits(
-        double value,
-        VisibleDigits &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    digits.clear();
-    if (uprv_isNaN(value)) {
-        digits.setNaN();
-        return digits;
-    }
-    if (uprv_isPositiveInfinity(value)) {
-        digits.setInfinite();
-        return digits;
-    }
-    if (uprv_isNegativeInfinity(value)) {
-        digits.setInfinite();
-        digits.setNegative();
-        return digits;
-    }
-    if (!fRoundingIncrement.isZero()) {
-        // If we have round increment, use digit list.
-        DigitList digitList;
-        digitList.set(value);
-        return initVisibleDigits(digitList, digits, status);
-    }
-    // Try to find n such that value * 10^n is an integer
-    int32_t n = -1;
-    double scaled;
-    for (int32_t i = 0; i < UPRV_LENGTHOF(gPower10); ++i) {
-        scaled = value * gPower10[i];
-        if (scaled > MAX_INT64_IN_DOUBLE || scaled < -MAX_INT64_IN_DOUBLE) {
-            break;
-        }
-        if (scaled == floor(scaled)) {
-            n = i;
-            break;
-        }
-    }
-    // Try fast path
-    if (n >= 0 && initVisibleDigits(static_cast<int64_t>(scaled), -n, digits, status)) {
-        digits.fAbsDoubleValue = fabs(value);
-        digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits();
-        // Adjust for negative 0 because when we cast to an int64,
-        // negative 0 becomes positive 0.
-        if (scaled == 0.0 && uprv_isNegative(scaled)) {
-            digits.setNegative();
-        }
-        return digits;
-    }
-
-    // Oops have to use digit list
-    DigitList digitList;
-    digitList.set(value);
-    return initVisibleDigits(digitList, digits, status);
-}
-
-UBool
-FixedPrecision::initVisibleDigits(
-        int64_t mantissa,
-        int32_t exponent,
-        VisibleDigits &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return TRUE;
-    }
-    digits.clear();
-
-    // Precompute fAbsIntValue if it is small enough, but we don't know yet
-    // if it will be valid.
-    UBool absIntValueComputed = FALSE;
-    if (mantissa > -1000000000000000000LL /* -1e18 */
-            && mantissa < 1000000000000000000LL /* 1e18 */) {
-        digits.fAbsIntValue = mantissa;
-        if (digits.fAbsIntValue < 0) {
-            digits.fAbsIntValue = -digits.fAbsIntValue;
-        }
-        int32_t i = 0;
-        int32_t maxPower10Exp = UPRV_LENGTHOF(gPower10) - 1;
-        for (; i > exponent + maxPower10Exp; i -= maxPower10Exp) {
-            digits.fAbsIntValue /= gPower10[maxPower10Exp];
-        }
-        digits.fAbsIntValue /= gPower10[i - exponent];
-        absIntValueComputed = TRUE;
-    }
-    if (mantissa == 0) {
-        getIntervalForZero(digits.fInterval);
-        digits.fAbsIntValueSet = absIntValueComputed;
-        return TRUE;
-    }
-    // be sure least significant digit is non zero
-    while (mantissa % 10 == 0) {
-        mantissa /= 10;
-        ++exponent;
-    }
-    if (mantissa < 0) {
-        digits.fDigits.append((char) -(mantissa % -10), status);
-        mantissa /= -10;
-        digits.setNegative();
-    }
-    while (mantissa) {
-        digits.fDigits.append((char) (mantissa % 10), status);
-        mantissa /= 10;
-    }
-    if (U_FAILURE(status)) {
-        return TRUE;
-    }
-    digits.fExponent = exponent;
-    int32_t upperExponent = exponent + digits.fDigits.length();
-    if (fFailIfOverMax && upperExponent > fMax.getIntDigitCount()) {
-        status = U_ILLEGAL_ARGUMENT_ERROR;
-        return TRUE;
-    }
-    UBool roundingRequired =
-            isRoundingRequired(upperExponent, exponent);
-    if (roundingRequired) {
-        if (fExactOnly) {
-            status = U_FORMAT_INEXACT_ERROR;
-            return TRUE;
-        }
-        return FALSE;
-    }
-    digits.fInterval.setLeastSignificantInclusive(exponent);
-    digits.fInterval.setMostSignificantExclusive(upperExponent);
-    getInterval(upperExponent, digits.fInterval);
-
-    // The intValue we computed above is only valid if our visible digits
-    // doesn't exceed the maximum integer digits allowed.
-    digits.fAbsIntValueSet = absIntValueComputed && !digits.isOverMaxDigits();
-    return TRUE;
-}
-
-VisibleDigitsWithExponent &
-FixedPrecision::initVisibleDigitsWithExponent(
-        DigitList &value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    digits.clear();
-    initVisibleDigits(value, digits.fMantissa, status);
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-FixedPrecision::initVisibleDigitsWithExponent(
-        double value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    digits.clear();
-    initVisibleDigits(value, digits.fMantissa, status);
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-FixedPrecision::initVisibleDigitsWithExponent(
-        int64_t value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    digits.clear();
-    initVisibleDigits(value, digits.fMantissa, status);
-    return digits;
-}
-
-ScientificPrecision::ScientificPrecision() : fMinExponentDigits(1) {
-}
-
-DigitList &
-ScientificPrecision::round(DigitList &value, UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return value;
-    }
-    int32_t exponent = value.getScientificExponent(
-            fMantissa.fMin.getIntDigitCount(), getMultiplier());
-    return fMantissa.round(value, exponent, status);
-}
-
-int32_t
-ScientificPrecision::toScientific(DigitList &value) const {
-    return value.toScientific(
-            fMantissa.fMin.getIntDigitCount(), getMultiplier());
-}
-
-int32_t
-ScientificPrecision::getMultiplier() const {
-    int32_t maxIntDigitCount = fMantissa.fMax.getIntDigitCount();
-    if (maxIntDigitCount == INT32_MAX) {
-        return 1;
-    }
-    int32_t multiplier =
-        maxIntDigitCount - fMantissa.fMin.getIntDigitCount() + 1;
-    return (multiplier < 1 ? 1 : multiplier);
-}
-
-VisibleDigitsWithExponent &
-ScientificPrecision::initVisibleDigitsWithExponent(
-        DigitList &value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    digits.clear();
-    if (FixedPrecision::handleNonNumeric(value, digits.fMantissa)) {
-        return digits;
-    }
-    value.setRoundingMode(fMantissa.fRoundingMode);
-    int64_t exponent = toScientific(round(value, status));
-    fMantissa.initVisibleDigits(value, digits.fMantissa, status);
-    FixedPrecision exponentPrecision;
-    exponentPrecision.fMin.setIntDigitCount(fMinExponentDigits);
-    exponentPrecision.initVisibleDigits(exponent, digits.fExponent, status);
-    digits.fHasExponent = TRUE;
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-ScientificPrecision::initVisibleDigitsWithExponent(
-        double value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    DigitList digitList;
-    digitList.set(value);
-    return initVisibleDigitsWithExponent(digitList, digits, status);
-}
-
-VisibleDigitsWithExponent &
-ScientificPrecision::initVisibleDigitsWithExponent(
-        int64_t value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    if (U_FAILURE(status)) {
-        return digits;
-    }
-    DigitList digitList;
-    digitList.set(value);
-    return initVisibleDigitsWithExponent(digitList, digits, status);
-}
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/precision.h b/deps/icu-small/source/i18n/precision.h
deleted file mode 100644
index 0598fa17d62771..00000000000000
--- a/deps/icu-small/source/i18n/precision.h
+++ /dev/null
@@ -1,323 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* precision.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __PRECISION_H__
-#define __PRECISION_H__
-
-#include "unicode/uobject.h"
-
-#if !UCONFIG_NO_FORMATTING
-#include "unicode/utypes.h"
-
-#include "digitinterval.h"
-#include "digitlst.h"
-#include "significantdigitinterval.h"
-
-U_NAMESPACE_BEGIN
-
-class VisibleDigits;
-class VisibleDigitsWithExponent;
-
-
-/**
- * A precision manager for values to be formatted as fixed point.
- * Handles rounding of number to prepare it for formatting.
- */
-class U_I18N_API FixedPrecision : public UMemory {
-public:
-
-    /**
-     * The smallest format interval allowed. Default is 1 integer digit and no
-     * fraction digits.
-     */
-    DigitInterval fMin;
-
-    /**
-     * The largest format interval allowed. Must contain fMin.
-     *  Default is all digits.
-     */
-    DigitInterval fMax;
-
-    /**
-     * Min and max significant digits allowed. The default is no constraints.
-     */
-    SignificantDigitInterval fSignificant;
-
-    /**
-     * The rounding increment or zero if there is no rounding increment.
-     * Default is zero.
-     */
-    DigitList fRoundingIncrement;
-
-    /**
-     * If set, causes round() to set status to U_FORMAT_INEXACT_ERROR if
-     * any rounding is done. Default is FALSE.
-     */
-    UBool fExactOnly;
-
-    /**
-     * If set, causes round() to set status to U_ILLEGAL_ARGUMENT_ERROR if
-     * rounded number has more than maximum integer digits. Default is FALSE.
-     */
-    UBool fFailIfOverMax;
-
-    /**
-     * Controls the rounding mode that initVisibleDigits uses.
-     * Default is DecimalFormat::kRoundHalfEven
-     */
-    DecimalFormat::ERoundingMode fRoundingMode;
-
-    FixedPrecision();
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const FixedPrecision &rhs) const {
-        return (fMin.equals(rhs.fMin) &&
-                fMax.equals(rhs.fMax) &&
-                fSignificant.equals(rhs.fSignificant) &&
-                (fRoundingIncrement == rhs.fRoundingIncrement) &&
-                fExactOnly == rhs.fExactOnly &&
-                fFailIfOverMax == rhs.fFailIfOverMax &&
-                fRoundingMode == rhs.fRoundingMode);
-    }
-
-    /**
-     * Rounds value in place to prepare it for formatting.
-     * @param value The value to be rounded. It is rounded in place.
-     * @param exponent Always pass 0 for fixed decimal formatting. scientific
-     *  precision passes the exponent value.  Essentially, it divides value by
-     *  10^exponent, rounds and then multiplies by 10^exponent.
-     * @param status error returned here.
-     * @return reference to value.
-     */
-    DigitList &round(DigitList &value, int32_t exponent, UErrorCode &status) const;
-
-    /**
-     * Returns the interval to use to format the rounded value.
-     * @param roundedValue the already rounded value to format.
-     * @param interval modified in place to be the interval to use to format
-     *   the rounded value.
-     * @return a reference to interval.
-     */
-    DigitInterval &getInterval(
-            const DigitList &roundedValue, DigitInterval &interval) const;
-
-    /**
-     * Returns TRUE if this instance allows for fast formatting of integers.
-     */
-    UBool isFastFormattable() const;
-
-    /**
-     * Initializes a VisibleDigits.
-     * @param value value for VisibleDigits
-     *    Caller must not assume that the value of this parameter will remain
-     *    unchanged.
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigits &initVisibleDigits(
-            DigitList &value,
-            VisibleDigits &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigits.
-     * @param value value for VisibleDigits
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigits &initVisibleDigits(
-            double value,
-            VisibleDigits &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigits.
-     * @param value value for VisibleDigits
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigits &initVisibleDigits(
-            int64_t value,
-            VisibleDigits &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value value for VisibleDigits
-     *    Caller must not assume that the value of this parameter will remain
-     *    unchanged.
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            DigitList &value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value value for VisibleDigits
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            double value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value value for VisibleDigits
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            int64_t value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-private:
-    /**
-     * Attempts to initialize 'digits' using simple mod 10 arithmetic.
-     * Returns FALSE if this is not possible such as when rounding
-     * would change the value. Otherwise returns TRUE.
-     *
-     * If the method returns FALSE, caller should create a DigitList
-     * and use it to initialize 'digits'. If this method returns TRUE,
-     * caller should accept the value stored in 'digits'. If this
-     * method returns TRUE along with a non zero error, caller must accept
-     * the error and not try again with a DigitList.
-     *
-     * Before calling this method, caller must verify that this object
-     * has no rounding increment set.
-     *
-     * The value that 'digits' is initialized to is mantissa * 10^exponent.
-     * For example mantissa = 54700 and exponent = -3 means 54.7. The
-     * properties of this object (such as min and max fraction digits),
-     * not the number of trailing zeros in the mantissa, determine whether or
-     * not the result contains any trailing 0's after the decimal point.
-     *
-     * @param mantissa the digits. May be positive or negative. May contain
-     *  trailing zeros.
-     * @param exponent must always be zero or negative. An exponent > 0
-     *  yields undefined results!
-     * @param digits result stored here.
-     * @param status any error returned here.
-     */
-    UBool
-    initVisibleDigits(
-            int64_t mantissa,
-            int32_t exponent,
-            VisibleDigits &digits,
-            UErrorCode &status) const;
-    UBool isRoundingRequired(
-            int32_t upperExponent, int32_t lowerExponent) const;
-    DigitInterval &getIntervalForZero(DigitInterval &interval) const;
-    DigitInterval &getInterval(
-            int32_t upperExponent, DigitInterval &interval) const;
-    static UBool handleNonNumeric(DigitList &value, VisibleDigits &digits);
-
-    friend class ScientificPrecision;
-};
-
-/**
- * A precision manager for values to be expressed as scientific notation.
- */
-class U_I18N_API ScientificPrecision : public UMemory {
-public:
-    FixedPrecision fMantissa;
-    int32_t fMinExponentDigits;
-
-    ScientificPrecision();
-
-    /**
-     * rounds value in place to prepare it for formatting.
-     * @param value The value to be rounded. It is rounded in place.
-     * @param status error returned here.
-     * @return reference to value.
-     */
-    DigitList &round(DigitList &value, UErrorCode &status) const;
-
-    /**
-     * Converts value to a mantissa and exponent.
-     *
-     * @param value modified in place to be the mantissa. Depending on
-     *   the precision settings, the resulting mantissa may not fall
-     *   between 1.0 and 10.0.
-     * @return the exponent of value.
-     */
-    int32_t toScientific(DigitList &value) const;
-
-    /**
-     * Returns TRUE if this object equals rhs.
-     */
-    UBool equals(const ScientificPrecision &rhs) const {
-        return fMantissa.equals(rhs.fMantissa) && fMinExponentDigits == rhs.fMinExponentDigits;
-    }
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value the value
-     *    Caller must not assume that the value of this parameter will remain
-     *    unchanged.
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            DigitList &value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value the value
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            double value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Initializes a VisibleDigitsWithExponent.
-     * @param value the value
-     * @param digits This is the value that is initialized.
-     * @param status any error returned here.
-     * @return digits
-     */
-    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-            int64_t value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-private:
-    int32_t getMultiplier() const;
-
-};
-
-
-
-U_NAMESPACE_END
-#endif // #if !UCONFIG_NO_FORMATTING
-#endif  // __PRECISION_H__
diff --git a/deps/icu-small/source/i18n/quantityformatter.cpp b/deps/icu-small/source/i18n/quantityformatter.cpp
index 208e064700ab2b..ba06ba06b97013 100644
--- a/deps/icu-small/source/i18n/quantityformatter.cpp
+++ b/deps/icu-small/source/i18n/quantityformatter.cpp
@@ -23,8 +23,8 @@
 #include "unicode/fmtable.h"
 #include "unicode/fieldpos.h"
 #include "standardplural.h"
-#include "visibledigits.h"
 #include "uassert.h"
+#include "number_decimalquantity.h"
 
 U_NAMESPACE_BEGIN
 
@@ -149,15 +149,15 @@ StandardPlural::Form QuantityFormatter::selectPlural(
         return StandardPlural::OTHER;
     }
     UnicodeString pluralKeyword;
-    VisibleDigitsWithExponent digits;
     const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(&fmt);
     if (decFmt != NULL) {
-        decFmt->initVisibleDigitsWithExponent(number, digits, status);
+        number::impl::DecimalQuantity dq;
+        decFmt->formatToDecimalQuantity(number, dq, status);
         if (U_FAILURE(status)) {
             return StandardPlural::OTHER;
         }
-        pluralKeyword = rules.select(digits);
-        decFmt->format(digits, formattedNumber, pos, status);
+        pluralKeyword = rules.select(dq);
+        decFmt->format(number, formattedNumber, pos, status);
     } else {
         if (number.getType() == Formattable::kDouble) {
             pluralKeyword = rules.select(number.getDouble());
diff --git a/deps/icu-small/source/i18n/rbnf.cpp b/deps/icu-small/source/i18n/rbnf.cpp
index 3385f300b11afe..ab9ad15e8c720d 100644
--- a/deps/icu-small/source/i18n/rbnf.cpp
+++ b/deps/icu-small/source/i18n/rbnf.cpp
@@ -34,7 +34,7 @@
 #include "patternprops.h"
 #include "uresimp.h"
 #include "nfrs.h"
-#include "digitlst.h"
+#include "number_decimalquantity.h"
 
 // debugging
 // #define RBNF_DEBUG
@@ -68,6 +68,8 @@ static const UChar gSemiPercent[] =
 
 U_NAMESPACE_BEGIN
 
+using number::impl::DecimalQuantity;
+
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedNumberFormat)
 
 /*
@@ -1109,21 +1111,21 @@ RuleBasedNumberFormat::findRuleSet(const UnicodeString& name, UErrorCode& status
 }
 
 UnicodeString&
-RuleBasedNumberFormat::format(const DigitList &number,
+RuleBasedNumberFormat::format(const DecimalQuantity &number,
                       UnicodeString &appendTo,
                       FieldPositionIterator *posIter,
                       UErrorCode &status) const {
     if (U_FAILURE(status)) {
         return appendTo;
     }
-    DigitList copy(number);
-    if (copy.fitsIntoInt64(false)) {
-        format(((DigitList &)number).getInt64(), appendTo, posIter, status);
+    DecimalQuantity copy(number);
+    if (copy.fitsInLong()) {
+        format(number.toLong(), appendTo, posIter, status);
     }
     else {
-        copy.roundAtExponent(0);
-        if (copy.fitsIntoInt64(false)) {
-            format(number.getDouble(), appendTo, posIter, status);
+        copy.roundToMagnitude(0, number::impl::RoundingMode::UNUM_ROUND_HALFEVEN, status);
+        if (copy.fitsInLong()) {
+            format(number.toDouble(), appendTo, posIter, status);
         }
         else {
             // We're outside of our normal range that this framework can handle.
@@ -1132,7 +1134,7 @@ RuleBasedNumberFormat::format(const DigitList &number,
             // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J.
             NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status);
             Formattable f;
-            f.adoptDigitList(new DigitList(number));
+            f.adoptDecimalQuantity(new DecimalQuantity(number));
             decimalFormat->format(f, appendTo, posIter, status);
             delete decimalFormat;
         }
@@ -1142,21 +1144,21 @@ RuleBasedNumberFormat::format(const DigitList &number,
 
 
 UnicodeString&
-RuleBasedNumberFormat::format(const DigitList &number,
+RuleBasedNumberFormat::format(const DecimalQuantity &number,
                      UnicodeString& appendTo,
                      FieldPosition& pos,
                      UErrorCode &status) const {
     if (U_FAILURE(status)) {
         return appendTo;
     }
-    DigitList copy(number);
-    if (copy.fitsIntoInt64(false)) {
-        format(((DigitList &)number).getInt64(), appendTo, pos, status);
+    DecimalQuantity copy(number);
+    if (copy.fitsInLong()) {
+        format(number.toLong(), appendTo, pos, status);
     }
     else {
-        copy.roundAtExponent(0);
-        if (copy.fitsIntoInt64(false)) {
-            format(number.getDouble(), appendTo, pos, status);
+        copy.roundToMagnitude(0, number::impl::RoundingMode::UNUM_ROUND_HALFEVEN, status);
+        if (copy.fitsInLong()) {
+            format(number.toDouble(), appendTo, pos, status);
         }
         else {
             // We're outside of our normal range that this framework can handle.
@@ -1165,7 +1167,7 @@ RuleBasedNumberFormat::format(const DigitList &number,
             // TODO this section should probably be optimized. The DecimalFormat is shared in ICU4J.
             NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status);
             Formattable f;
-            f.adoptDigitList(new DigitList(number));
+            f.adoptDecimalQuantity(new DecimalQuantity(number));
             decimalFormat->format(f, appendTo, pos, status);
             delete decimalFormat;
         }
@@ -1270,11 +1272,13 @@ RuleBasedNumberFormat::format(double number,
 {
     int32_t startPos = toAppendTo.length();
     if (getRoundingMode() != DecimalFormat::ERoundingMode::kRoundUnnecessary && !uprv_isNaN(number) && !uprv_isInfinite(number)) {
-        DigitList digitList;
-        digitList.set(number);
-        digitList.setRoundingMode(getRoundingMode());
-        digitList.roundFixedPoint(getMaximumFractionDigits());
-        number = digitList.getDouble();
+        DecimalQuantity digitList;
+        digitList.setToDouble(number);
+        digitList.roundToMagnitude(
+                -getMaximumFractionDigits(),
+                static_cast<UNumberFormatRoundingMode>(getRoundingMode()),
+                status);
+        number = digitList.toDouble();
     }
     rs.format(number, toAppendTo, toAppendTo.length(), 0, status);
     adjustForCapitalizationContext(startPos, toAppendTo, status);
@@ -1310,9 +1314,9 @@ RuleBasedNumberFormat::format(int64_t number, NFRuleSet *ruleSet, UnicodeString&
             NumberFormat *decimalFormat = NumberFormat::createInstance(locale, UNUM_DECIMAL, status);
             Formattable f;
             FieldPosition pos(FieldPosition::DONT_CARE);
-            DigitList *digitList = new DigitList();
-            digitList->set(number);
-            f.adoptDigitList(digitList);
+            DecimalQuantity *digitList = new DecimalQuantity();
+            digitList->setToLong(number);
+            f.adoptDecimalQuantity(digitList);
             decimalFormat->format(f, toAppendTo, pos, status);
             delete decimalFormat;
         }
diff --git a/deps/icu-small/source/i18n/reldatefmt.cpp b/deps/icu-small/source/i18n/reldatefmt.cpp
index 5cf053db9a98fb..42ede7ae4d9903 100644
--- a/deps/icu-small/source/i18n/reldatefmt.cpp
+++ b/deps/icu-small/source/i18n/reldatefmt.cpp
@@ -14,6 +14,7 @@
 
 #if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_BREAK_ITERATION
 
+#include <cmath>
 #include "unicode/dtfmtsym.h"
 #include "unicode/ucasemap.h"
 #include "unicode/ureldatefmt.h"
@@ -849,7 +850,7 @@ UnicodeString& RelativeDateTimeFormatter::formatNumeric(
             return appendTo;
     }
     UDateDirection direction = UDAT_DIRECTION_NEXT;
-    if (offset < 0) {
+    if (std::signbit(offset)) { // needed to handle -0.0
         direction = UDAT_DIRECTION_LAST;
         offset = -offset;
     }
diff --git a/deps/icu-small/source/i18n/scientificnumberformatter.cpp b/deps/icu-small/source/i18n/scientificnumberformatter.cpp
index adf032d989dd90..03d98dd6e100e2 100644
--- a/deps/icu-small/source/i18n/scientificnumberformatter.cpp
+++ b/deps/icu-small/source/i18n/scientificnumberformatter.cpp
@@ -15,8 +15,8 @@
 #include "unicode/fpositer.h"
 #include "unicode/utf16.h"
 #include "unicode/uniset.h"
-#include "decfmtst.h"
 #include "unicode/decimfmt.h"
+#include "static_unicode_sets.h"
 
 U_NAMESPACE_BEGIN
 
@@ -129,7 +129,6 @@ UnicodeString &ScientificNumberFormatter::SuperscriptStyle::format(
         const UnicodeString &original,
         FieldPositionIterator &fpi,
         const UnicodeString &preExponent,
-        const DecimalFormatStaticSets &staticSets,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
@@ -149,16 +148,17 @@ UnicodeString &ScientificNumberFormatter::SuperscriptStyle::format(
             break;
         case UNUM_EXPONENT_SIGN_FIELD:
             {
+                using namespace icu::numparse::impl;
                 int32_t beginIndex = fp.getBeginIndex();
                 int32_t endIndex = fp.getEndIndex();
                 UChar32 aChar = original.char32At(beginIndex);
-                if (staticSets.fMinusSigns->contains(aChar)) {
+                if (unisets::get(unisets::MINUS_SIGN)->contains(aChar)) {
                     appendTo.append(
                             original,
                             copyFromOffset,
                             beginIndex - copyFromOffset);
                     appendTo.append(kSuperscriptMinusSign);
-                } else if (staticSets.fPlusSigns->contains(aChar)) {
+                } else if (unisets::get(unisets::PLUS_SIGN)->contains(aChar)) {
                     appendTo.append(
                            original,
                            copyFromOffset,
@@ -203,7 +203,6 @@ UnicodeString &ScientificNumberFormatter::MarkupStyle::format(
         const UnicodeString &original,
         FieldPositionIterator &fpi,
         const UnicodeString &preExponent,
-        const DecimalFormatStaticSets & /*unusedDecimalFormatSets*/,
         UnicodeString &appendTo,
         UErrorCode &status) const {
     if (U_FAILURE(status)) {
@@ -243,8 +242,7 @@ ScientificNumberFormatter::ScientificNumberFormatter(
         DecimalFormat *fmtToAdopt, Style *styleToAdopt, UErrorCode &status)
         : fPreExponent(),
           fDecimalFormat(fmtToAdopt),
-          fStyle(styleToAdopt),
-          fStaticSets(NULL) {
+          fStyle(styleToAdopt) {
     if (U_FAILURE(status)) {
         return;
     }
@@ -258,7 +256,6 @@ ScientificNumberFormatter::ScientificNumberFormatter(
         return;
     }
     getPreExponent(*sym, fPreExponent);
-    fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
 }
 
 ScientificNumberFormatter::ScientificNumberFormatter(
@@ -266,8 +263,7 @@ ScientificNumberFormatter::ScientificNumberFormatter(
         : UObject(other),
           fPreExponent(other.fPreExponent),
           fDecimalFormat(NULL),
-          fStyle(NULL),
-          fStaticSets(other.fStaticSets) {
+          fStyle(NULL) {
     fDecimalFormat = static_cast<DecimalFormat *>(
             other.fDecimalFormat->clone());
     fStyle = other.fStyle->clone();
@@ -292,7 +288,6 @@ UnicodeString &ScientificNumberFormatter::format(
             original,
             fpi,
             fPreExponent,
-            *fStaticSets,
             appendTo,
             status);
 }
diff --git a/deps/icu-small/source/i18n/significantdigitinterval.h b/deps/icu-small/source/i18n/significantdigitinterval.h
deleted file mode 100644
index fc23370de5b6fd..00000000000000
--- a/deps/icu-small/source/i18n/significantdigitinterval.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* significantdigitinterval.h
-*
-* created on: 2015jan6
-* created by: Travis Keep
-*/
-
-#ifndef __SIGNIFICANTDIGITINTERVAL_H__
-#define __SIGNIFICANTDIGITINTERVAL_H__
-
-#include "unicode/uobject.h"
-#include "unicode/utypes.h"
-
-U_NAMESPACE_BEGIN
-
-/**
- * An interval of allowed significant digit counts.
- */
-class U_I18N_API SignificantDigitInterval : public UMemory {
-public:
-
-    /**
-     * No limits on significant digits.
-     */
-    SignificantDigitInterval()
-            : fMax(INT32_MAX), fMin(0) { }
-
-    /**
-     * Make this instance have no limit on significant digits.
-     */
-    void clear() {
-        fMin = 0;
-        fMax = INT32_MAX;
-    }
-
-    /**
-     * Returns TRUE if this object is equal to rhs.
-     */
-    UBool equals(const SignificantDigitInterval &rhs) const {
-        return ((fMax == rhs.fMax) && (fMin == rhs.fMin));
-    }
-
-    /**
-     * Sets maximum significant digits. 0 or negative means no maximum.
-     */
-    void setMax(int32_t count) {
-        fMax = count <= 0 ? INT32_MAX : count;
-    }
-
-    /**
-     * Get maximum significant digits. INT32_MAX means no maximum.
-     */
-    int32_t getMax() const {
-        return fMax;
-    }
-
-    /**
-     * Sets minimum significant digits. 0 or negative means no minimum.
-     */
-    void setMin(int32_t count) {
-        fMin = count <= 0 ? 0 : count;
-    }
-
-    /**
-     * Get maximum significant digits. 0 means no minimum.
-     */
-    int32_t getMin() const {
-        return fMin;
-    }
-
-    /**
-     * Returns TRUE if this instance represents no constraints on significant
-     * digits.
-     */
-    UBool isNoConstraints() const {
-        return fMin == 0 && fMax == INT32_MAX;
-    }
-
-private:
-    int32_t fMax;
-    int32_t fMin;
-};
-
-U_NAMESPACE_END
-
-#endif  // __SIGNIFICANTDIGITINTERVAL_H__
diff --git a/deps/icu-small/source/i18n/smallintformatter.cpp b/deps/icu-small/source/i18n/smallintformatter.cpp
deleted file mode 100644
index 0c56e38bd69560..00000000000000
--- a/deps/icu-small/source/i18n/smallintformatter.cpp
+++ /dev/null
@@ -1,2622 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2015, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: smallintformatter.cpp
- */
-
-#include "unicode/unistr.h"
-
-#include "smallintformatter.h"
-
-static const int32_t gMaxFastInt = 4096;
-
-static const UChar gDigits[] = {
-        0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x31,
-        0x30,0x30,0x30,0x32,0x30,0x30,0x30,0x33,
-        0x30,0x30,0x30,0x34,0x30,0x30,0x30,0x35,
-        0x30,0x30,0x30,0x36,0x30,0x30,0x30,0x37,
-        0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x39,
-        0x30,0x30,0x31,0x30,0x30,0x30,0x31,0x31,
-        0x30,0x30,0x31,0x32,0x30,0x30,0x31,0x33,
-        0x30,0x30,0x31,0x34,0x30,0x30,0x31,0x35,
-        0x30,0x30,0x31,0x36,0x30,0x30,0x31,0x37,
-        0x30,0x30,0x31,0x38,0x30,0x30,0x31,0x39,
-        0x30,0x30,0x32,0x30,0x30,0x30,0x32,0x31,
-        0x30,0x30,0x32,0x32,0x30,0x30,0x32,0x33,
-        0x30,0x30,0x32,0x34,0x30,0x30,0x32,0x35,
-        0x30,0x30,0x32,0x36,0x30,0x30,0x32,0x37,
-        0x30,0x30,0x32,0x38,0x30,0x30,0x32,0x39,
-        0x30,0x30,0x33,0x30,0x30,0x30,0x33,0x31,
-        0x30,0x30,0x33,0x32,0x30,0x30,0x33,0x33,
-        0x30,0x30,0x33,0x34,0x30,0x30,0x33,0x35,
-        0x30,0x30,0x33,0x36,0x30,0x30,0x33,0x37,
-        0x30,0x30,0x33,0x38,0x30,0x30,0x33,0x39,
-        0x30,0x30,0x34,0x30,0x30,0x30,0x34,0x31,
-        0x30,0x30,0x34,0x32,0x30,0x30,0x34,0x33,
-        0x30,0x30,0x34,0x34,0x30,0x30,0x34,0x35,
-        0x30,0x30,0x34,0x36,0x30,0x30,0x34,0x37,
-        0x30,0x30,0x34,0x38,0x30,0x30,0x34,0x39,
-        0x30,0x30,0x35,0x30,0x30,0x30,0x35,0x31,
-        0x30,0x30,0x35,0x32,0x30,0x30,0x35,0x33,
-        0x30,0x30,0x35,0x34,0x30,0x30,0x35,0x35,
-        0x30,0x30,0x35,0x36,0x30,0x30,0x35,0x37,
-        0x30,0x30,0x35,0x38,0x30,0x30,0x35,0x39,
-        0x30,0x30,0x36,0x30,0x30,0x30,0x36,0x31,
-        0x30,0x30,0x36,0x32,0x30,0x30,0x36,0x33,
-        0x30,0x30,0x36,0x34,0x30,0x30,0x36,0x35,
-        0x30,0x30,0x36,0x36,0x30,0x30,0x36,0x37,
-        0x30,0x30,0x36,0x38,0x30,0x30,0x36,0x39,
-        0x30,0x30,0x37,0x30,0x30,0x30,0x37,0x31,
-        0x30,0x30,0x37,0x32,0x30,0x30,0x37,0x33,
-        0x30,0x30,0x37,0x34,0x30,0x30,0x37,0x35,
-        0x30,0x30,0x37,0x36,0x30,0x30,0x37,0x37,
-        0x30,0x30,0x37,0x38,0x30,0x30,0x37,0x39,
-        0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x31,
-        0x30,0x30,0x38,0x32,0x30,0x30,0x38,0x33,
-        0x30,0x30,0x38,0x34,0x30,0x30,0x38,0x35,
-        0x30,0x30,0x38,0x36,0x30,0x30,0x38,0x37,
-        0x30,0x30,0x38,0x38,0x30,0x30,0x38,0x39,
-        0x30,0x30,0x39,0x30,0x30,0x30,0x39,0x31,
-        0x30,0x30,0x39,0x32,0x30,0x30,0x39,0x33,
-        0x30,0x30,0x39,0x34,0x30,0x30,0x39,0x35,
-        0x30,0x30,0x39,0x36,0x30,0x30,0x39,0x37,
-        0x30,0x30,0x39,0x38,0x30,0x30,0x39,0x39,
-        0x30,0x31,0x30,0x30,0x30,0x31,0x30,0x31,
-        0x30,0x31,0x30,0x32,0x30,0x31,0x30,0x33,
-        0x30,0x31,0x30,0x34,0x30,0x31,0x30,0x35,
-        0x30,0x31,0x30,0x36,0x30,0x31,0x30,0x37,
-        0x30,0x31,0x30,0x38,0x30,0x31,0x30,0x39,
-        0x30,0x31,0x31,0x30,0x30,0x31,0x31,0x31,
-        0x30,0x31,0x31,0x32,0x30,0x31,0x31,0x33,
-        0x30,0x31,0x31,0x34,0x30,0x31,0x31,0x35,
-        0x30,0x31,0x31,0x36,0x30,0x31,0x31,0x37,
-        0x30,0x31,0x31,0x38,0x30,0x31,0x31,0x39,
-        0x30,0x31,0x32,0x30,0x30,0x31,0x32,0x31,
-        0x30,0x31,0x32,0x32,0x30,0x31,0x32,0x33,
-        0x30,0x31,0x32,0x34,0x30,0x31,0x32,0x35,
-        0x30,0x31,0x32,0x36,0x30,0x31,0x32,0x37,
-        0x30,0x31,0x32,0x38,0x30,0x31,0x32,0x39,
-        0x30,0x31,0x33,0x30,0x30,0x31,0x33,0x31,
-        0x30,0x31,0x33,0x32,0x30,0x31,0x33,0x33,
-        0x30,0x31,0x33,0x34,0x30,0x31,0x33,0x35,
-        0x30,0x31,0x33,0x36,0x30,0x31,0x33,0x37,
-        0x30,0x31,0x33,0x38,0x30,0x31,0x33,0x39,
-        0x30,0x31,0x34,0x30,0x30,0x31,0x34,0x31,
-        0x30,0x31,0x34,0x32,0x30,0x31,0x34,0x33,
-        0x30,0x31,0x34,0x34,0x30,0x31,0x34,0x35,
-        0x30,0x31,0x34,0x36,0x30,0x31,0x34,0x37,
-        0x30,0x31,0x34,0x38,0x30,0x31,0x34,0x39,
-        0x30,0x31,0x35,0x30,0x30,0x31,0x35,0x31,
-        0x30,0x31,0x35,0x32,0x30,0x31,0x35,0x33,
-        0x30,0x31,0x35,0x34,0x30,0x31,0x35,0x35,
-        0x30,0x31,0x35,0x36,0x30,0x31,0x35,0x37,
-        0x30,0x31,0x35,0x38,0x30,0x31,0x35,0x39,
-        0x30,0x31,0x36,0x30,0x30,0x31,0x36,0x31,
-        0x30,0x31,0x36,0x32,0x30,0x31,0x36,0x33,
-        0x30,0x31,0x36,0x34,0x30,0x31,0x36,0x35,
-        0x30,0x31,0x36,0x36,0x30,0x31,0x36,0x37,
-        0x30,0x31,0x36,0x38,0x30,0x31,0x36,0x39,
-        0x30,0x31,0x37,0x30,0x30,0x31,0x37,0x31,
-        0x30,0x31,0x37,0x32,0x30,0x31,0x37,0x33,
-        0x30,0x31,0x37,0x34,0x30,0x31,0x37,0x35,
-        0x30,0x31,0x37,0x36,0x30,0x31,0x37,0x37,
-        0x30,0x31,0x37,0x38,0x30,0x31,0x37,0x39,
-        0x30,0x31,0x38,0x30,0x30,0x31,0x38,0x31,
-        0x30,0x31,0x38,0x32,0x30,0x31,0x38,0x33,
-        0x30,0x31,0x38,0x34,0x30,0x31,0x38,0x35,
-        0x30,0x31,0x38,0x36,0x30,0x31,0x38,0x37,
-        0x30,0x31,0x38,0x38,0x30,0x31,0x38,0x39,
-        0x30,0x31,0x39,0x30,0x30,0x31,0x39,0x31,
-        0x30,0x31,0x39,0x32,0x30,0x31,0x39,0x33,
-        0x30,0x31,0x39,0x34,0x30,0x31,0x39,0x35,
-        0x30,0x31,0x39,0x36,0x30,0x31,0x39,0x37,
-        0x30,0x31,0x39,0x38,0x30,0x31,0x39,0x39,
-        0x30,0x32,0x30,0x30,0x30,0x32,0x30,0x31,
-        0x30,0x32,0x30,0x32,0x30,0x32,0x30,0x33,
-        0x30,0x32,0x30,0x34,0x30,0x32,0x30,0x35,
-        0x30,0x32,0x30,0x36,0x30,0x32,0x30,0x37,
-        0x30,0x32,0x30,0x38,0x30,0x32,0x30,0x39,
-        0x30,0x32,0x31,0x30,0x30,0x32,0x31,0x31,
-        0x30,0x32,0x31,0x32,0x30,0x32,0x31,0x33,
-        0x30,0x32,0x31,0x34,0x30,0x32,0x31,0x35,
-        0x30,0x32,0x31,0x36,0x30,0x32,0x31,0x37,
-        0x30,0x32,0x31,0x38,0x30,0x32,0x31,0x39,
-        0x30,0x32,0x32,0x30,0x30,0x32,0x32,0x31,
-        0x30,0x32,0x32,0x32,0x30,0x32,0x32,0x33,
-        0x30,0x32,0x32,0x34,0x30,0x32,0x32,0x35,
-        0x30,0x32,0x32,0x36,0x30,0x32,0x32,0x37,
-        0x30,0x32,0x32,0x38,0x30,0x32,0x32,0x39,
-        0x30,0x32,0x33,0x30,0x30,0x32,0x33,0x31,
-        0x30,0x32,0x33,0x32,0x30,0x32,0x33,0x33,
-        0x30,0x32,0x33,0x34,0x30,0x32,0x33,0x35,
-        0x30,0x32,0x33,0x36,0x30,0x32,0x33,0x37,
-        0x30,0x32,0x33,0x38,0x30,0x32,0x33,0x39,
-        0x30,0x32,0x34,0x30,0x30,0x32,0x34,0x31,
-        0x30,0x32,0x34,0x32,0x30,0x32,0x34,0x33,
-        0x30,0x32,0x34,0x34,0x30,0x32,0x34,0x35,
-        0x30,0x32,0x34,0x36,0x30,0x32,0x34,0x37,
-        0x30,0x32,0x34,0x38,0x30,0x32,0x34,0x39,
-        0x30,0x32,0x35,0x30,0x30,0x32,0x35,0x31,
-        0x30,0x32,0x35,0x32,0x30,0x32,0x35,0x33,
-        0x30,0x32,0x35,0x34,0x30,0x32,0x35,0x35,
-        0x30,0x32,0x35,0x36,0x30,0x32,0x35,0x37,
-        0x30,0x32,0x35,0x38,0x30,0x32,0x35,0x39,
-        0x30,0x32,0x36,0x30,0x30,0x32,0x36,0x31,
-        0x30,0x32,0x36,0x32,0x30,0x32,0x36,0x33,
-        0x30,0x32,0x36,0x34,0x30,0x32,0x36,0x35,
-        0x30,0x32,0x36,0x36,0x30,0x32,0x36,0x37,
-        0x30,0x32,0x36,0x38,0x30,0x32,0x36,0x39,
-        0x30,0x32,0x37,0x30,0x30,0x32,0x37,0x31,
-        0x30,0x32,0x37,0x32,0x30,0x32,0x37,0x33,
-        0x30,0x32,0x37,0x34,0x30,0x32,0x37,0x35,
-        0x30,0x32,0x37,0x36,0x30,0x32,0x37,0x37,
-        0x30,0x32,0x37,0x38,0x30,0x32,0x37,0x39,
-        0x30,0x32,0x38,0x30,0x30,0x32,0x38,0x31,
-        0x30,0x32,0x38,0x32,0x30,0x32,0x38,0x33,
-        0x30,0x32,0x38,0x34,0x30,0x32,0x38,0x35,
-        0x30,0x32,0x38,0x36,0x30,0x32,0x38,0x37,
-        0x30,0x32,0x38,0x38,0x30,0x32,0x38,0x39,
-        0x30,0x32,0x39,0x30,0x30,0x32,0x39,0x31,
-        0x30,0x32,0x39,0x32,0x30,0x32,0x39,0x33,
-        0x30,0x32,0x39,0x34,0x30,0x32,0x39,0x35,
-        0x30,0x32,0x39,0x36,0x30,0x32,0x39,0x37,
-        0x30,0x32,0x39,0x38,0x30,0x32,0x39,0x39,
-        0x30,0x33,0x30,0x30,0x30,0x33,0x30,0x31,
-        0x30,0x33,0x30,0x32,0x30,0x33,0x30,0x33,
-        0x30,0x33,0x30,0x34,0x30,0x33,0x30,0x35,
-        0x30,0x33,0x30,0x36,0x30,0x33,0x30,0x37,
-        0x30,0x33,0x30,0x38,0x30,0x33,0x30,0x39,
-        0x30,0x33,0x31,0x30,0x30,0x33,0x31,0x31,
-        0x30,0x33,0x31,0x32,0x30,0x33,0x31,0x33,
-        0x30,0x33,0x31,0x34,0x30,0x33,0x31,0x35,
-        0x30,0x33,0x31,0x36,0x30,0x33,0x31,0x37,
-        0x30,0x33,0x31,0x38,0x30,0x33,0x31,0x39,
-        0x30,0x33,0x32,0x30,0x30,0x33,0x32,0x31,
-        0x30,0x33,0x32,0x32,0x30,0x33,0x32,0x33,
-        0x30,0x33,0x32,0x34,0x30,0x33,0x32,0x35,
-        0x30,0x33,0x32,0x36,0x30,0x33,0x32,0x37,
-        0x30,0x33,0x32,0x38,0x30,0x33,0x32,0x39,
-        0x30,0x33,0x33,0x30,0x30,0x33,0x33,0x31,
-        0x30,0x33,0x33,0x32,0x30,0x33,0x33,0x33,
-        0x30,0x33,0x33,0x34,0x30,0x33,0x33,0x35,
-        0x30,0x33,0x33,0x36,0x30,0x33,0x33,0x37,
-        0x30,0x33,0x33,0x38,0x30,0x33,0x33,0x39,
-        0x30,0x33,0x34,0x30,0x30,0x33,0x34,0x31,
-        0x30,0x33,0x34,0x32,0x30,0x33,0x34,0x33,
-        0x30,0x33,0x34,0x34,0x30,0x33,0x34,0x35,
-        0x30,0x33,0x34,0x36,0x30,0x33,0x34,0x37,
-        0x30,0x33,0x34,0x38,0x30,0x33,0x34,0x39,
-        0x30,0x33,0x35,0x30,0x30,0x33,0x35,0x31,
-        0x30,0x33,0x35,0x32,0x30,0x33,0x35,0x33,
-        0x30,0x33,0x35,0x34,0x30,0x33,0x35,0x35,
-        0x30,0x33,0x35,0x36,0x30,0x33,0x35,0x37,
-        0x30,0x33,0x35,0x38,0x30,0x33,0x35,0x39,
-        0x30,0x33,0x36,0x30,0x30,0x33,0x36,0x31,
-        0x30,0x33,0x36,0x32,0x30,0x33,0x36,0x33,
-        0x30,0x33,0x36,0x34,0x30,0x33,0x36,0x35,
-        0x30,0x33,0x36,0x36,0x30,0x33,0x36,0x37,
-        0x30,0x33,0x36,0x38,0x30,0x33,0x36,0x39,
-        0x30,0x33,0x37,0x30,0x30,0x33,0x37,0x31,
-        0x30,0x33,0x37,0x32,0x30,0x33,0x37,0x33,
-        0x30,0x33,0x37,0x34,0x30,0x33,0x37,0x35,
-        0x30,0x33,0x37,0x36,0x30,0x33,0x37,0x37,
-        0x30,0x33,0x37,0x38,0x30,0x33,0x37,0x39,
-        0x30,0x33,0x38,0x30,0x30,0x33,0x38,0x31,
-        0x30,0x33,0x38,0x32,0x30,0x33,0x38,0x33,
-        0x30,0x33,0x38,0x34,0x30,0x33,0x38,0x35,
-        0x30,0x33,0x38,0x36,0x30,0x33,0x38,0x37,
-        0x30,0x33,0x38,0x38,0x30,0x33,0x38,0x39,
-        0x30,0x33,0x39,0x30,0x30,0x33,0x39,0x31,
-        0x30,0x33,0x39,0x32,0x30,0x33,0x39,0x33,
-        0x30,0x33,0x39,0x34,0x30,0x33,0x39,0x35,
-        0x30,0x33,0x39,0x36,0x30,0x33,0x39,0x37,
-        0x30,0x33,0x39,0x38,0x30,0x33,0x39,0x39,
-        0x30,0x34,0x30,0x30,0x30,0x34,0x30,0x31,
-        0x30,0x34,0x30,0x32,0x30,0x34,0x30,0x33,
-        0x30,0x34,0x30,0x34,0x30,0x34,0x30,0x35,
-        0x30,0x34,0x30,0x36,0x30,0x34,0x30,0x37,
-        0x30,0x34,0x30,0x38,0x30,0x34,0x30,0x39,
-        0x30,0x34,0x31,0x30,0x30,0x34,0x31,0x31,
-        0x30,0x34,0x31,0x32,0x30,0x34,0x31,0x33,
-        0x30,0x34,0x31,0x34,0x30,0x34,0x31,0x35,
-        0x30,0x34,0x31,0x36,0x30,0x34,0x31,0x37,
-        0x30,0x34,0x31,0x38,0x30,0x34,0x31,0x39,
-        0x30,0x34,0x32,0x30,0x30,0x34,0x32,0x31,
-        0x30,0x34,0x32,0x32,0x30,0x34,0x32,0x33,
-        0x30,0x34,0x32,0x34,0x30,0x34,0x32,0x35,
-        0x30,0x34,0x32,0x36,0x30,0x34,0x32,0x37,
-        0x30,0x34,0x32,0x38,0x30,0x34,0x32,0x39,
-        0x30,0x34,0x33,0x30,0x30,0x34,0x33,0x31,
-        0x30,0x34,0x33,0x32,0x30,0x34,0x33,0x33,
-        0x30,0x34,0x33,0x34,0x30,0x34,0x33,0x35,
-        0x30,0x34,0x33,0x36,0x30,0x34,0x33,0x37,
-        0x30,0x34,0x33,0x38,0x30,0x34,0x33,0x39,
-        0x30,0x34,0x34,0x30,0x30,0x34,0x34,0x31,
-        0x30,0x34,0x34,0x32,0x30,0x34,0x34,0x33,
-        0x30,0x34,0x34,0x34,0x30,0x34,0x34,0x35,
-        0x30,0x34,0x34,0x36,0x30,0x34,0x34,0x37,
-        0x30,0x34,0x34,0x38,0x30,0x34,0x34,0x39,
-        0x30,0x34,0x35,0x30,0x30,0x34,0x35,0x31,
-        0x30,0x34,0x35,0x32,0x30,0x34,0x35,0x33,
-        0x30,0x34,0x35,0x34,0x30,0x34,0x35,0x35,
-        0x30,0x34,0x35,0x36,0x30,0x34,0x35,0x37,
-        0x30,0x34,0x35,0x38,0x30,0x34,0x35,0x39,
-        0x30,0x34,0x36,0x30,0x30,0x34,0x36,0x31,
-        0x30,0x34,0x36,0x32,0x30,0x34,0x36,0x33,
-        0x30,0x34,0x36,0x34,0x30,0x34,0x36,0x35,
-        0x30,0x34,0x36,0x36,0x30,0x34,0x36,0x37,
-        0x30,0x34,0x36,0x38,0x30,0x34,0x36,0x39,
-        0x30,0x34,0x37,0x30,0x30,0x34,0x37,0x31,
-        0x30,0x34,0x37,0x32,0x30,0x34,0x37,0x33,
-        0x30,0x34,0x37,0x34,0x30,0x34,0x37,0x35,
-        0x30,0x34,0x37,0x36,0x30,0x34,0x37,0x37,
-        0x30,0x34,0x37,0x38,0x30,0x34,0x37,0x39,
-        0x30,0x34,0x38,0x30,0x30,0x34,0x38,0x31,
-        0x30,0x34,0x38,0x32,0x30,0x34,0x38,0x33,
-        0x30,0x34,0x38,0x34,0x30,0x34,0x38,0x35,
-        0x30,0x34,0x38,0x36,0x30,0x34,0x38,0x37,
-        0x30,0x34,0x38,0x38,0x30,0x34,0x38,0x39,
-        0x30,0x34,0x39,0x30,0x30,0x34,0x39,0x31,
-        0x30,0x34,0x39,0x32,0x30,0x34,0x39,0x33,
-        0x30,0x34,0x39,0x34,0x30,0x34,0x39,0x35,
-        0x30,0x34,0x39,0x36,0x30,0x34,0x39,0x37,
-        0x30,0x34,0x39,0x38,0x30,0x34,0x39,0x39,
-        0x30,0x35,0x30,0x30,0x30,0x35,0x30,0x31,
-        0x30,0x35,0x30,0x32,0x30,0x35,0x30,0x33,
-        0x30,0x35,0x30,0x34,0x30,0x35,0x30,0x35,
-        0x30,0x35,0x30,0x36,0x30,0x35,0x30,0x37,
-        0x30,0x35,0x30,0x38,0x30,0x35,0x30,0x39,
-        0x30,0x35,0x31,0x30,0x30,0x35,0x31,0x31,
-        0x30,0x35,0x31,0x32,0x30,0x35,0x31,0x33,
-        0x30,0x35,0x31,0x34,0x30,0x35,0x31,0x35,
-        0x30,0x35,0x31,0x36,0x30,0x35,0x31,0x37,
-        0x30,0x35,0x31,0x38,0x30,0x35,0x31,0x39,
-        0x30,0x35,0x32,0x30,0x30,0x35,0x32,0x31,
-        0x30,0x35,0x32,0x32,0x30,0x35,0x32,0x33,
-        0x30,0x35,0x32,0x34,0x30,0x35,0x32,0x35,
-        0x30,0x35,0x32,0x36,0x30,0x35,0x32,0x37,
-        0x30,0x35,0x32,0x38,0x30,0x35,0x32,0x39,
-        0x30,0x35,0x33,0x30,0x30,0x35,0x33,0x31,
-        0x30,0x35,0x33,0x32,0x30,0x35,0x33,0x33,
-        0x30,0x35,0x33,0x34,0x30,0x35,0x33,0x35,
-        0x30,0x35,0x33,0x36,0x30,0x35,0x33,0x37,
-        0x30,0x35,0x33,0x38,0x30,0x35,0x33,0x39,
-        0x30,0x35,0x34,0x30,0x30,0x35,0x34,0x31,
-        0x30,0x35,0x34,0x32,0x30,0x35,0x34,0x33,
-        0x30,0x35,0x34,0x34,0x30,0x35,0x34,0x35,
-        0x30,0x35,0x34,0x36,0x30,0x35,0x34,0x37,
-        0x30,0x35,0x34,0x38,0x30,0x35,0x34,0x39,
-        0x30,0x35,0x35,0x30,0x30,0x35,0x35,0x31,
-        0x30,0x35,0x35,0x32,0x30,0x35,0x35,0x33,
-        0x30,0x35,0x35,0x34,0x30,0x35,0x35,0x35,
-        0x30,0x35,0x35,0x36,0x30,0x35,0x35,0x37,
-        0x30,0x35,0x35,0x38,0x30,0x35,0x35,0x39,
-        0x30,0x35,0x36,0x30,0x30,0x35,0x36,0x31,
-        0x30,0x35,0x36,0x32,0x30,0x35,0x36,0x33,
-        0x30,0x35,0x36,0x34,0x30,0x35,0x36,0x35,
-        0x30,0x35,0x36,0x36,0x30,0x35,0x36,0x37,
-        0x30,0x35,0x36,0x38,0x30,0x35,0x36,0x39,
-        0x30,0x35,0x37,0x30,0x30,0x35,0x37,0x31,
-        0x30,0x35,0x37,0x32,0x30,0x35,0x37,0x33,
-        0x30,0x35,0x37,0x34,0x30,0x35,0x37,0x35,
-        0x30,0x35,0x37,0x36,0x30,0x35,0x37,0x37,
-        0x30,0x35,0x37,0x38,0x30,0x35,0x37,0x39,
-        0x30,0x35,0x38,0x30,0x30,0x35,0x38,0x31,
-        0x30,0x35,0x38,0x32,0x30,0x35,0x38,0x33,
-        0x30,0x35,0x38,0x34,0x30,0x35,0x38,0x35,
-        0x30,0x35,0x38,0x36,0x30,0x35,0x38,0x37,
-        0x30,0x35,0x38,0x38,0x30,0x35,0x38,0x39,
-        0x30,0x35,0x39,0x30,0x30,0x35,0x39,0x31,
-        0x30,0x35,0x39,0x32,0x30,0x35,0x39,0x33,
-        0x30,0x35,0x39,0x34,0x30,0x35,0x39,0x35,
-        0x30,0x35,0x39,0x36,0x30,0x35,0x39,0x37,
-        0x30,0x35,0x39,0x38,0x30,0x35,0x39,0x39,
-        0x30,0x36,0x30,0x30,0x30,0x36,0x30,0x31,
-        0x30,0x36,0x30,0x32,0x30,0x36,0x30,0x33,
-        0x30,0x36,0x30,0x34,0x30,0x36,0x30,0x35,
-        0x30,0x36,0x30,0x36,0x30,0x36,0x30,0x37,
-        0x30,0x36,0x30,0x38,0x30,0x36,0x30,0x39,
-        0x30,0x36,0x31,0x30,0x30,0x36,0x31,0x31,
-        0x30,0x36,0x31,0x32,0x30,0x36,0x31,0x33,
-        0x30,0x36,0x31,0x34,0x30,0x36,0x31,0x35,
-        0x30,0x36,0x31,0x36,0x30,0x36,0x31,0x37,
-        0x30,0x36,0x31,0x38,0x30,0x36,0x31,0x39,
-        0x30,0x36,0x32,0x30,0x30,0x36,0x32,0x31,
-        0x30,0x36,0x32,0x32,0x30,0x36,0x32,0x33,
-        0x30,0x36,0x32,0x34,0x30,0x36,0x32,0x35,
-        0x30,0x36,0x32,0x36,0x30,0x36,0x32,0x37,
-        0x30,0x36,0x32,0x38,0x30,0x36,0x32,0x39,
-        0x30,0x36,0x33,0x30,0x30,0x36,0x33,0x31,
-        0x30,0x36,0x33,0x32,0x30,0x36,0x33,0x33,
-        0x30,0x36,0x33,0x34,0x30,0x36,0x33,0x35,
-        0x30,0x36,0x33,0x36,0x30,0x36,0x33,0x37,
-        0x30,0x36,0x33,0x38,0x30,0x36,0x33,0x39,
-        0x30,0x36,0x34,0x30,0x30,0x36,0x34,0x31,
-        0x30,0x36,0x34,0x32,0x30,0x36,0x34,0x33,
-        0x30,0x36,0x34,0x34,0x30,0x36,0x34,0x35,
-        0x30,0x36,0x34,0x36,0x30,0x36,0x34,0x37,
-        0x30,0x36,0x34,0x38,0x30,0x36,0x34,0x39,
-        0x30,0x36,0x35,0x30,0x30,0x36,0x35,0x31,
-        0x30,0x36,0x35,0x32,0x30,0x36,0x35,0x33,
-        0x30,0x36,0x35,0x34,0x30,0x36,0x35,0x35,
-        0x30,0x36,0x35,0x36,0x30,0x36,0x35,0x37,
-        0x30,0x36,0x35,0x38,0x30,0x36,0x35,0x39,
-        0x30,0x36,0x36,0x30,0x30,0x36,0x36,0x31,
-        0x30,0x36,0x36,0x32,0x30,0x36,0x36,0x33,
-        0x30,0x36,0x36,0x34,0x30,0x36,0x36,0x35,
-        0x30,0x36,0x36,0x36,0x30,0x36,0x36,0x37,
-        0x30,0x36,0x36,0x38,0x30,0x36,0x36,0x39,
-        0x30,0x36,0x37,0x30,0x30,0x36,0x37,0x31,
-        0x30,0x36,0x37,0x32,0x30,0x36,0x37,0x33,
-        0x30,0x36,0x37,0x34,0x30,0x36,0x37,0x35,
-        0x30,0x36,0x37,0x36,0x30,0x36,0x37,0x37,
-        0x30,0x36,0x37,0x38,0x30,0x36,0x37,0x39,
-        0x30,0x36,0x38,0x30,0x30,0x36,0x38,0x31,
-        0x30,0x36,0x38,0x32,0x30,0x36,0x38,0x33,
-        0x30,0x36,0x38,0x34,0x30,0x36,0x38,0x35,
-        0x30,0x36,0x38,0x36,0x30,0x36,0x38,0x37,
-        0x30,0x36,0x38,0x38,0x30,0x36,0x38,0x39,
-        0x30,0x36,0x39,0x30,0x30,0x36,0x39,0x31,
-        0x30,0x36,0x39,0x32,0x30,0x36,0x39,0x33,
-        0x30,0x36,0x39,0x34,0x30,0x36,0x39,0x35,
-        0x30,0x36,0x39,0x36,0x30,0x36,0x39,0x37,
-        0x30,0x36,0x39,0x38,0x30,0x36,0x39,0x39,
-        0x30,0x37,0x30,0x30,0x30,0x37,0x30,0x31,
-        0x30,0x37,0x30,0x32,0x30,0x37,0x30,0x33,
-        0x30,0x37,0x30,0x34,0x30,0x37,0x30,0x35,
-        0x30,0x37,0x30,0x36,0x30,0x37,0x30,0x37,
-        0x30,0x37,0x30,0x38,0x30,0x37,0x30,0x39,
-        0x30,0x37,0x31,0x30,0x30,0x37,0x31,0x31,
-        0x30,0x37,0x31,0x32,0x30,0x37,0x31,0x33,
-        0x30,0x37,0x31,0x34,0x30,0x37,0x31,0x35,
-        0x30,0x37,0x31,0x36,0x30,0x37,0x31,0x37,
-        0x30,0x37,0x31,0x38,0x30,0x37,0x31,0x39,
-        0x30,0x37,0x32,0x30,0x30,0x37,0x32,0x31,
-        0x30,0x37,0x32,0x32,0x30,0x37,0x32,0x33,
-        0x30,0x37,0x32,0x34,0x30,0x37,0x32,0x35,
-        0x30,0x37,0x32,0x36,0x30,0x37,0x32,0x37,
-        0x30,0x37,0x32,0x38,0x30,0x37,0x32,0x39,
-        0x30,0x37,0x33,0x30,0x30,0x37,0x33,0x31,
-        0x30,0x37,0x33,0x32,0x30,0x37,0x33,0x33,
-        0x30,0x37,0x33,0x34,0x30,0x37,0x33,0x35,
-        0x30,0x37,0x33,0x36,0x30,0x37,0x33,0x37,
-        0x30,0x37,0x33,0x38,0x30,0x37,0x33,0x39,
-        0x30,0x37,0x34,0x30,0x30,0x37,0x34,0x31,
-        0x30,0x37,0x34,0x32,0x30,0x37,0x34,0x33,
-        0x30,0x37,0x34,0x34,0x30,0x37,0x34,0x35,
-        0x30,0x37,0x34,0x36,0x30,0x37,0x34,0x37,
-        0x30,0x37,0x34,0x38,0x30,0x37,0x34,0x39,
-        0x30,0x37,0x35,0x30,0x30,0x37,0x35,0x31,
-        0x30,0x37,0x35,0x32,0x30,0x37,0x35,0x33,
-        0x30,0x37,0x35,0x34,0x30,0x37,0x35,0x35,
-        0x30,0x37,0x35,0x36,0x30,0x37,0x35,0x37,
-        0x30,0x37,0x35,0x38,0x30,0x37,0x35,0x39,
-        0x30,0x37,0x36,0x30,0x30,0x37,0x36,0x31,
-        0x30,0x37,0x36,0x32,0x30,0x37,0x36,0x33,
-        0x30,0x37,0x36,0x34,0x30,0x37,0x36,0x35,
-        0x30,0x37,0x36,0x36,0x30,0x37,0x36,0x37,
-        0x30,0x37,0x36,0x38,0x30,0x37,0x36,0x39,
-        0x30,0x37,0x37,0x30,0x30,0x37,0x37,0x31,
-        0x30,0x37,0x37,0x32,0x30,0x37,0x37,0x33,
-        0x30,0x37,0x37,0x34,0x30,0x37,0x37,0x35,
-        0x30,0x37,0x37,0x36,0x30,0x37,0x37,0x37,
-        0x30,0x37,0x37,0x38,0x30,0x37,0x37,0x39,
-        0x30,0x37,0x38,0x30,0x30,0x37,0x38,0x31,
-        0x30,0x37,0x38,0x32,0x30,0x37,0x38,0x33,
-        0x30,0x37,0x38,0x34,0x30,0x37,0x38,0x35,
-        0x30,0x37,0x38,0x36,0x30,0x37,0x38,0x37,
-        0x30,0x37,0x38,0x38,0x30,0x37,0x38,0x39,
-        0x30,0x37,0x39,0x30,0x30,0x37,0x39,0x31,
-        0x30,0x37,0x39,0x32,0x30,0x37,0x39,0x33,
-        0x30,0x37,0x39,0x34,0x30,0x37,0x39,0x35,
-        0x30,0x37,0x39,0x36,0x30,0x37,0x39,0x37,
-        0x30,0x37,0x39,0x38,0x30,0x37,0x39,0x39,
-        0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x31,
-        0x30,0x38,0x30,0x32,0x30,0x38,0x30,0x33,
-        0x30,0x38,0x30,0x34,0x30,0x38,0x30,0x35,
-        0x30,0x38,0x30,0x36,0x30,0x38,0x30,0x37,
-        0x30,0x38,0x30,0x38,0x30,0x38,0x30,0x39,
-        0x30,0x38,0x31,0x30,0x30,0x38,0x31,0x31,
-        0x30,0x38,0x31,0x32,0x30,0x38,0x31,0x33,
-        0x30,0x38,0x31,0x34,0x30,0x38,0x31,0x35,
-        0x30,0x38,0x31,0x36,0x30,0x38,0x31,0x37,
-        0x30,0x38,0x31,0x38,0x30,0x38,0x31,0x39,
-        0x30,0x38,0x32,0x30,0x30,0x38,0x32,0x31,
-        0x30,0x38,0x32,0x32,0x30,0x38,0x32,0x33,
-        0x30,0x38,0x32,0x34,0x30,0x38,0x32,0x35,
-        0x30,0x38,0x32,0x36,0x30,0x38,0x32,0x37,
-        0x30,0x38,0x32,0x38,0x30,0x38,0x32,0x39,
-        0x30,0x38,0x33,0x30,0x30,0x38,0x33,0x31,
-        0x30,0x38,0x33,0x32,0x30,0x38,0x33,0x33,
-        0x30,0x38,0x33,0x34,0x30,0x38,0x33,0x35,
-        0x30,0x38,0x33,0x36,0x30,0x38,0x33,0x37,
-        0x30,0x38,0x33,0x38,0x30,0x38,0x33,0x39,
-        0x30,0x38,0x34,0x30,0x30,0x38,0x34,0x31,
-        0x30,0x38,0x34,0x32,0x30,0x38,0x34,0x33,
-        0x30,0x38,0x34,0x34,0x30,0x38,0x34,0x35,
-        0x30,0x38,0x34,0x36,0x30,0x38,0x34,0x37,
-        0x30,0x38,0x34,0x38,0x30,0x38,0x34,0x39,
-        0x30,0x38,0x35,0x30,0x30,0x38,0x35,0x31,
-        0x30,0x38,0x35,0x32,0x30,0x38,0x35,0x33,
-        0x30,0x38,0x35,0x34,0x30,0x38,0x35,0x35,
-        0x30,0x38,0x35,0x36,0x30,0x38,0x35,0x37,
-        0x30,0x38,0x35,0x38,0x30,0x38,0x35,0x39,
-        0x30,0x38,0x36,0x30,0x30,0x38,0x36,0x31,
-        0x30,0x38,0x36,0x32,0x30,0x38,0x36,0x33,
-        0x30,0x38,0x36,0x34,0x30,0x38,0x36,0x35,
-        0x30,0x38,0x36,0x36,0x30,0x38,0x36,0x37,
-        0x30,0x38,0x36,0x38,0x30,0x38,0x36,0x39,
-        0x30,0x38,0x37,0x30,0x30,0x38,0x37,0x31,
-        0x30,0x38,0x37,0x32,0x30,0x38,0x37,0x33,
-        0x30,0x38,0x37,0x34,0x30,0x38,0x37,0x35,
-        0x30,0x38,0x37,0x36,0x30,0x38,0x37,0x37,
-        0x30,0x38,0x37,0x38,0x30,0x38,0x37,0x39,
-        0x30,0x38,0x38,0x30,0x30,0x38,0x38,0x31,
-        0x30,0x38,0x38,0x32,0x30,0x38,0x38,0x33,
-        0x30,0x38,0x38,0x34,0x30,0x38,0x38,0x35,
-        0x30,0x38,0x38,0x36,0x30,0x38,0x38,0x37,
-        0x30,0x38,0x38,0x38,0x30,0x38,0x38,0x39,
-        0x30,0x38,0x39,0x30,0x30,0x38,0x39,0x31,
-        0x30,0x38,0x39,0x32,0x30,0x38,0x39,0x33,
-        0x30,0x38,0x39,0x34,0x30,0x38,0x39,0x35,
-        0x30,0x38,0x39,0x36,0x30,0x38,0x39,0x37,
-        0x30,0x38,0x39,0x38,0x30,0x38,0x39,0x39,
-        0x30,0x39,0x30,0x30,0x30,0x39,0x30,0x31,
-        0x30,0x39,0x30,0x32,0x30,0x39,0x30,0x33,
-        0x30,0x39,0x30,0x34,0x30,0x39,0x30,0x35,
-        0x30,0x39,0x30,0x36,0x30,0x39,0x30,0x37,
-        0x30,0x39,0x30,0x38,0x30,0x39,0x30,0x39,
-        0x30,0x39,0x31,0x30,0x30,0x39,0x31,0x31,
-        0x30,0x39,0x31,0x32,0x30,0x39,0x31,0x33,
-        0x30,0x39,0x31,0x34,0x30,0x39,0x31,0x35,
-        0x30,0x39,0x31,0x36,0x30,0x39,0x31,0x37,
-        0x30,0x39,0x31,0x38,0x30,0x39,0x31,0x39,
-        0x30,0x39,0x32,0x30,0x30,0x39,0x32,0x31,
-        0x30,0x39,0x32,0x32,0x30,0x39,0x32,0x33,
-        0x30,0x39,0x32,0x34,0x30,0x39,0x32,0x35,
-        0x30,0x39,0x32,0x36,0x30,0x39,0x32,0x37,
-        0x30,0x39,0x32,0x38,0x30,0x39,0x32,0x39,
-        0x30,0x39,0x33,0x30,0x30,0x39,0x33,0x31,
-        0x30,0x39,0x33,0x32,0x30,0x39,0x33,0x33,
-        0x30,0x39,0x33,0x34,0x30,0x39,0x33,0x35,
-        0x30,0x39,0x33,0x36,0x30,0x39,0x33,0x37,
-        0x30,0x39,0x33,0x38,0x30,0x39,0x33,0x39,
-        0x30,0x39,0x34,0x30,0x30,0x39,0x34,0x31,
-        0x30,0x39,0x34,0x32,0x30,0x39,0x34,0x33,
-        0x30,0x39,0x34,0x34,0x30,0x39,0x34,0x35,
-        0x30,0x39,0x34,0x36,0x30,0x39,0x34,0x37,
-        0x30,0x39,0x34,0x38,0x30,0x39,0x34,0x39,
-        0x30,0x39,0x35,0x30,0x30,0x39,0x35,0x31,
-        0x30,0x39,0x35,0x32,0x30,0x39,0x35,0x33,
-        0x30,0x39,0x35,0x34,0x30,0x39,0x35,0x35,
-        0x30,0x39,0x35,0x36,0x30,0x39,0x35,0x37,
-        0x30,0x39,0x35,0x38,0x30,0x39,0x35,0x39,
-        0x30,0x39,0x36,0x30,0x30,0x39,0x36,0x31,
-        0x30,0x39,0x36,0x32,0x30,0x39,0x36,0x33,
-        0x30,0x39,0x36,0x34,0x30,0x39,0x36,0x35,
-        0x30,0x39,0x36,0x36,0x30,0x39,0x36,0x37,
-        0x30,0x39,0x36,0x38,0x30,0x39,0x36,0x39,
-        0x30,0x39,0x37,0x30,0x30,0x39,0x37,0x31,
-        0x30,0x39,0x37,0x32,0x30,0x39,0x37,0x33,
-        0x30,0x39,0x37,0x34,0x30,0x39,0x37,0x35,
-        0x30,0x39,0x37,0x36,0x30,0x39,0x37,0x37,
-        0x30,0x39,0x37,0x38,0x30,0x39,0x37,0x39,
-        0x30,0x39,0x38,0x30,0x30,0x39,0x38,0x31,
-        0x30,0x39,0x38,0x32,0x30,0x39,0x38,0x33,
-        0x30,0x39,0x38,0x34,0x30,0x39,0x38,0x35,
-        0x30,0x39,0x38,0x36,0x30,0x39,0x38,0x37,
-        0x30,0x39,0x38,0x38,0x30,0x39,0x38,0x39,
-        0x30,0x39,0x39,0x30,0x30,0x39,0x39,0x31,
-        0x30,0x39,0x39,0x32,0x30,0x39,0x39,0x33,
-        0x30,0x39,0x39,0x34,0x30,0x39,0x39,0x35,
-        0x30,0x39,0x39,0x36,0x30,0x39,0x39,0x37,
-        0x30,0x39,0x39,0x38,0x30,0x39,0x39,0x39,
-        0x31,0x30,0x30,0x30,0x31,0x30,0x30,0x31,
-        0x31,0x30,0x30,0x32,0x31,0x30,0x30,0x33,
-        0x31,0x30,0x30,0x34,0x31,0x30,0x30,0x35,
-        0x31,0x30,0x30,0x36,0x31,0x30,0x30,0x37,
-        0x31,0x30,0x30,0x38,0x31,0x30,0x30,0x39,
-        0x31,0x30,0x31,0x30,0x31,0x30,0x31,0x31,
-        0x31,0x30,0x31,0x32,0x31,0x30,0x31,0x33,
-        0x31,0x30,0x31,0x34,0x31,0x30,0x31,0x35,
-        0x31,0x30,0x31,0x36,0x31,0x30,0x31,0x37,
-        0x31,0x30,0x31,0x38,0x31,0x30,0x31,0x39,
-        0x31,0x30,0x32,0x30,0x31,0x30,0x32,0x31,
-        0x31,0x30,0x32,0x32,0x31,0x30,0x32,0x33,
-        0x31,0x30,0x32,0x34,0x31,0x30,0x32,0x35,
-        0x31,0x30,0x32,0x36,0x31,0x30,0x32,0x37,
-        0x31,0x30,0x32,0x38,0x31,0x30,0x32,0x39,
-        0x31,0x30,0x33,0x30,0x31,0x30,0x33,0x31,
-        0x31,0x30,0x33,0x32,0x31,0x30,0x33,0x33,
-        0x31,0x30,0x33,0x34,0x31,0x30,0x33,0x35,
-        0x31,0x30,0x33,0x36,0x31,0x30,0x33,0x37,
-        0x31,0x30,0x33,0x38,0x31,0x30,0x33,0x39,
-        0x31,0x30,0x34,0x30,0x31,0x30,0x34,0x31,
-        0x31,0x30,0x34,0x32,0x31,0x30,0x34,0x33,
-        0x31,0x30,0x34,0x34,0x31,0x30,0x34,0x35,
-        0x31,0x30,0x34,0x36,0x31,0x30,0x34,0x37,
-        0x31,0x30,0x34,0x38,0x31,0x30,0x34,0x39,
-        0x31,0x30,0x35,0x30,0x31,0x30,0x35,0x31,
-        0x31,0x30,0x35,0x32,0x31,0x30,0x35,0x33,
-        0x31,0x30,0x35,0x34,0x31,0x30,0x35,0x35,
-        0x31,0x30,0x35,0x36,0x31,0x30,0x35,0x37,
-        0x31,0x30,0x35,0x38,0x31,0x30,0x35,0x39,
-        0x31,0x30,0x36,0x30,0x31,0x30,0x36,0x31,
-        0x31,0x30,0x36,0x32,0x31,0x30,0x36,0x33,
-        0x31,0x30,0x36,0x34,0x31,0x30,0x36,0x35,
-        0x31,0x30,0x36,0x36,0x31,0x30,0x36,0x37,
-        0x31,0x30,0x36,0x38,0x31,0x30,0x36,0x39,
-        0x31,0x30,0x37,0x30,0x31,0x30,0x37,0x31,
-        0x31,0x30,0x37,0x32,0x31,0x30,0x37,0x33,
-        0x31,0x30,0x37,0x34,0x31,0x30,0x37,0x35,
-        0x31,0x30,0x37,0x36,0x31,0x30,0x37,0x37,
-        0x31,0x30,0x37,0x38,0x31,0x30,0x37,0x39,
-        0x31,0x30,0x38,0x30,0x31,0x30,0x38,0x31,
-        0x31,0x30,0x38,0x32,0x31,0x30,0x38,0x33,
-        0x31,0x30,0x38,0x34,0x31,0x30,0x38,0x35,
-        0x31,0x30,0x38,0x36,0x31,0x30,0x38,0x37,
-        0x31,0x30,0x38,0x38,0x31,0x30,0x38,0x39,
-        0x31,0x30,0x39,0x30,0x31,0x30,0x39,0x31,
-        0x31,0x30,0x39,0x32,0x31,0x30,0x39,0x33,
-        0x31,0x30,0x39,0x34,0x31,0x30,0x39,0x35,
-        0x31,0x30,0x39,0x36,0x31,0x30,0x39,0x37,
-        0x31,0x30,0x39,0x38,0x31,0x30,0x39,0x39,
-        0x31,0x31,0x30,0x30,0x31,0x31,0x30,0x31,
-        0x31,0x31,0x30,0x32,0x31,0x31,0x30,0x33,
-        0x31,0x31,0x30,0x34,0x31,0x31,0x30,0x35,
-        0x31,0x31,0x30,0x36,0x31,0x31,0x30,0x37,
-        0x31,0x31,0x30,0x38,0x31,0x31,0x30,0x39,
-        0x31,0x31,0x31,0x30,0x31,0x31,0x31,0x31,
-        0x31,0x31,0x31,0x32,0x31,0x31,0x31,0x33,
-        0x31,0x31,0x31,0x34,0x31,0x31,0x31,0x35,
-        0x31,0x31,0x31,0x36,0x31,0x31,0x31,0x37,
-        0x31,0x31,0x31,0x38,0x31,0x31,0x31,0x39,
-        0x31,0x31,0x32,0x30,0x31,0x31,0x32,0x31,
-        0x31,0x31,0x32,0x32,0x31,0x31,0x32,0x33,
-        0x31,0x31,0x32,0x34,0x31,0x31,0x32,0x35,
-        0x31,0x31,0x32,0x36,0x31,0x31,0x32,0x37,
-        0x31,0x31,0x32,0x38,0x31,0x31,0x32,0x39,
-        0x31,0x31,0x33,0x30,0x31,0x31,0x33,0x31,
-        0x31,0x31,0x33,0x32,0x31,0x31,0x33,0x33,
-        0x31,0x31,0x33,0x34,0x31,0x31,0x33,0x35,
-        0x31,0x31,0x33,0x36,0x31,0x31,0x33,0x37,
-        0x31,0x31,0x33,0x38,0x31,0x31,0x33,0x39,
-        0x31,0x31,0x34,0x30,0x31,0x31,0x34,0x31,
-        0x31,0x31,0x34,0x32,0x31,0x31,0x34,0x33,
-        0x31,0x31,0x34,0x34,0x31,0x31,0x34,0x35,
-        0x31,0x31,0x34,0x36,0x31,0x31,0x34,0x37,
-        0x31,0x31,0x34,0x38,0x31,0x31,0x34,0x39,
-        0x31,0x31,0x35,0x30,0x31,0x31,0x35,0x31,
-        0x31,0x31,0x35,0x32,0x31,0x31,0x35,0x33,
-        0x31,0x31,0x35,0x34,0x31,0x31,0x35,0x35,
-        0x31,0x31,0x35,0x36,0x31,0x31,0x35,0x37,
-        0x31,0x31,0x35,0x38,0x31,0x31,0x35,0x39,
-        0x31,0x31,0x36,0x30,0x31,0x31,0x36,0x31,
-        0x31,0x31,0x36,0x32,0x31,0x31,0x36,0x33,
-        0x31,0x31,0x36,0x34,0x31,0x31,0x36,0x35,
-        0x31,0x31,0x36,0x36,0x31,0x31,0x36,0x37,
-        0x31,0x31,0x36,0x38,0x31,0x31,0x36,0x39,
-        0x31,0x31,0x37,0x30,0x31,0x31,0x37,0x31,
-        0x31,0x31,0x37,0x32,0x31,0x31,0x37,0x33,
-        0x31,0x31,0x37,0x34,0x31,0x31,0x37,0x35,
-        0x31,0x31,0x37,0x36,0x31,0x31,0x37,0x37,
-        0x31,0x31,0x37,0x38,0x31,0x31,0x37,0x39,
-        0x31,0x31,0x38,0x30,0x31,0x31,0x38,0x31,
-        0x31,0x31,0x38,0x32,0x31,0x31,0x38,0x33,
-        0x31,0x31,0x38,0x34,0x31,0x31,0x38,0x35,
-        0x31,0x31,0x38,0x36,0x31,0x31,0x38,0x37,
-        0x31,0x31,0x38,0x38,0x31,0x31,0x38,0x39,
-        0x31,0x31,0x39,0x30,0x31,0x31,0x39,0x31,
-        0x31,0x31,0x39,0x32,0x31,0x31,0x39,0x33,
-        0x31,0x31,0x39,0x34,0x31,0x31,0x39,0x35,
-        0x31,0x31,0x39,0x36,0x31,0x31,0x39,0x37,
-        0x31,0x31,0x39,0x38,0x31,0x31,0x39,0x39,
-        0x31,0x32,0x30,0x30,0x31,0x32,0x30,0x31,
-        0x31,0x32,0x30,0x32,0x31,0x32,0x30,0x33,
-        0x31,0x32,0x30,0x34,0x31,0x32,0x30,0x35,
-        0x31,0x32,0x30,0x36,0x31,0x32,0x30,0x37,
-        0x31,0x32,0x30,0x38,0x31,0x32,0x30,0x39,
-        0x31,0x32,0x31,0x30,0x31,0x32,0x31,0x31,
-        0x31,0x32,0x31,0x32,0x31,0x32,0x31,0x33,
-        0x31,0x32,0x31,0x34,0x31,0x32,0x31,0x35,
-        0x31,0x32,0x31,0x36,0x31,0x32,0x31,0x37,
-        0x31,0x32,0x31,0x38,0x31,0x32,0x31,0x39,
-        0x31,0x32,0x32,0x30,0x31,0x32,0x32,0x31,
-        0x31,0x32,0x32,0x32,0x31,0x32,0x32,0x33,
-        0x31,0x32,0x32,0x34,0x31,0x32,0x32,0x35,
-        0x31,0x32,0x32,0x36,0x31,0x32,0x32,0x37,
-        0x31,0x32,0x32,0x38,0x31,0x32,0x32,0x39,
-        0x31,0x32,0x33,0x30,0x31,0x32,0x33,0x31,
-        0x31,0x32,0x33,0x32,0x31,0x32,0x33,0x33,
-        0x31,0x32,0x33,0x34,0x31,0x32,0x33,0x35,
-        0x31,0x32,0x33,0x36,0x31,0x32,0x33,0x37,
-        0x31,0x32,0x33,0x38,0x31,0x32,0x33,0x39,
-        0x31,0x32,0x34,0x30,0x31,0x32,0x34,0x31,
-        0x31,0x32,0x34,0x32,0x31,0x32,0x34,0x33,
-        0x31,0x32,0x34,0x34,0x31,0x32,0x34,0x35,
-        0x31,0x32,0x34,0x36,0x31,0x32,0x34,0x37,
-        0x31,0x32,0x34,0x38,0x31,0x32,0x34,0x39,
-        0x31,0x32,0x35,0x30,0x31,0x32,0x35,0x31,
-        0x31,0x32,0x35,0x32,0x31,0x32,0x35,0x33,
-        0x31,0x32,0x35,0x34,0x31,0x32,0x35,0x35,
-        0x31,0x32,0x35,0x36,0x31,0x32,0x35,0x37,
-        0x31,0x32,0x35,0x38,0x31,0x32,0x35,0x39,
-        0x31,0x32,0x36,0x30,0x31,0x32,0x36,0x31,
-        0x31,0x32,0x36,0x32,0x31,0x32,0x36,0x33,
-        0x31,0x32,0x36,0x34,0x31,0x32,0x36,0x35,
-        0x31,0x32,0x36,0x36,0x31,0x32,0x36,0x37,
-        0x31,0x32,0x36,0x38,0x31,0x32,0x36,0x39,
-        0x31,0x32,0x37,0x30,0x31,0x32,0x37,0x31,
-        0x31,0x32,0x37,0x32,0x31,0x32,0x37,0x33,
-        0x31,0x32,0x37,0x34,0x31,0x32,0x37,0x35,
-        0x31,0x32,0x37,0x36,0x31,0x32,0x37,0x37,
-        0x31,0x32,0x37,0x38,0x31,0x32,0x37,0x39,
-        0x31,0x32,0x38,0x30,0x31,0x32,0x38,0x31,
-        0x31,0x32,0x38,0x32,0x31,0x32,0x38,0x33,
-        0x31,0x32,0x38,0x34,0x31,0x32,0x38,0x35,
-        0x31,0x32,0x38,0x36,0x31,0x32,0x38,0x37,
-        0x31,0x32,0x38,0x38,0x31,0x32,0x38,0x39,
-        0x31,0x32,0x39,0x30,0x31,0x32,0x39,0x31,
-        0x31,0x32,0x39,0x32,0x31,0x32,0x39,0x33,
-        0x31,0x32,0x39,0x34,0x31,0x32,0x39,0x35,
-        0x31,0x32,0x39,0x36,0x31,0x32,0x39,0x37,
-        0x31,0x32,0x39,0x38,0x31,0x32,0x39,0x39,
-        0x31,0x33,0x30,0x30,0x31,0x33,0x30,0x31,
-        0x31,0x33,0x30,0x32,0x31,0x33,0x30,0x33,
-        0x31,0x33,0x30,0x34,0x31,0x33,0x30,0x35,
-        0x31,0x33,0x30,0x36,0x31,0x33,0x30,0x37,
-        0x31,0x33,0x30,0x38,0x31,0x33,0x30,0x39,
-        0x31,0x33,0x31,0x30,0x31,0x33,0x31,0x31,
-        0x31,0x33,0x31,0x32,0x31,0x33,0x31,0x33,
-        0x31,0x33,0x31,0x34,0x31,0x33,0x31,0x35,
-        0x31,0x33,0x31,0x36,0x31,0x33,0x31,0x37,
-        0x31,0x33,0x31,0x38,0x31,0x33,0x31,0x39,
-        0x31,0x33,0x32,0x30,0x31,0x33,0x32,0x31,
-        0x31,0x33,0x32,0x32,0x31,0x33,0x32,0x33,
-        0x31,0x33,0x32,0x34,0x31,0x33,0x32,0x35,
-        0x31,0x33,0x32,0x36,0x31,0x33,0x32,0x37,
-        0x31,0x33,0x32,0x38,0x31,0x33,0x32,0x39,
-        0x31,0x33,0x33,0x30,0x31,0x33,0x33,0x31,
-        0x31,0x33,0x33,0x32,0x31,0x33,0x33,0x33,
-        0x31,0x33,0x33,0x34,0x31,0x33,0x33,0x35,
-        0x31,0x33,0x33,0x36,0x31,0x33,0x33,0x37,
-        0x31,0x33,0x33,0x38,0x31,0x33,0x33,0x39,
-        0x31,0x33,0x34,0x30,0x31,0x33,0x34,0x31,
-        0x31,0x33,0x34,0x32,0x31,0x33,0x34,0x33,
-        0x31,0x33,0x34,0x34,0x31,0x33,0x34,0x35,
-        0x31,0x33,0x34,0x36,0x31,0x33,0x34,0x37,
-        0x31,0x33,0x34,0x38,0x31,0x33,0x34,0x39,
-        0x31,0x33,0x35,0x30,0x31,0x33,0x35,0x31,
-        0x31,0x33,0x35,0x32,0x31,0x33,0x35,0x33,
-        0x31,0x33,0x35,0x34,0x31,0x33,0x35,0x35,
-        0x31,0x33,0x35,0x36,0x31,0x33,0x35,0x37,
-        0x31,0x33,0x35,0x38,0x31,0x33,0x35,0x39,
-        0x31,0x33,0x36,0x30,0x31,0x33,0x36,0x31,
-        0x31,0x33,0x36,0x32,0x31,0x33,0x36,0x33,
-        0x31,0x33,0x36,0x34,0x31,0x33,0x36,0x35,
-        0x31,0x33,0x36,0x36,0x31,0x33,0x36,0x37,
-        0x31,0x33,0x36,0x38,0x31,0x33,0x36,0x39,
-        0x31,0x33,0x37,0x30,0x31,0x33,0x37,0x31,
-        0x31,0x33,0x37,0x32,0x31,0x33,0x37,0x33,
-        0x31,0x33,0x37,0x34,0x31,0x33,0x37,0x35,
-        0x31,0x33,0x37,0x36,0x31,0x33,0x37,0x37,
-        0x31,0x33,0x37,0x38,0x31,0x33,0x37,0x39,
-        0x31,0x33,0x38,0x30,0x31,0x33,0x38,0x31,
-        0x31,0x33,0x38,0x32,0x31,0x33,0x38,0x33,
-        0x31,0x33,0x38,0x34,0x31,0x33,0x38,0x35,
-        0x31,0x33,0x38,0x36,0x31,0x33,0x38,0x37,
-        0x31,0x33,0x38,0x38,0x31,0x33,0x38,0x39,
-        0x31,0x33,0x39,0x30,0x31,0x33,0x39,0x31,
-        0x31,0x33,0x39,0x32,0x31,0x33,0x39,0x33,
-        0x31,0x33,0x39,0x34,0x31,0x33,0x39,0x35,
-        0x31,0x33,0x39,0x36,0x31,0x33,0x39,0x37,
-        0x31,0x33,0x39,0x38,0x31,0x33,0x39,0x39,
-        0x31,0x34,0x30,0x30,0x31,0x34,0x30,0x31,
-        0x31,0x34,0x30,0x32,0x31,0x34,0x30,0x33,
-        0x31,0x34,0x30,0x34,0x31,0x34,0x30,0x35,
-        0x31,0x34,0x30,0x36,0x31,0x34,0x30,0x37,
-        0x31,0x34,0x30,0x38,0x31,0x34,0x30,0x39,
-        0x31,0x34,0x31,0x30,0x31,0x34,0x31,0x31,
-        0x31,0x34,0x31,0x32,0x31,0x34,0x31,0x33,
-        0x31,0x34,0x31,0x34,0x31,0x34,0x31,0x35,
-        0x31,0x34,0x31,0x36,0x31,0x34,0x31,0x37,
-        0x31,0x34,0x31,0x38,0x31,0x34,0x31,0x39,
-        0x31,0x34,0x32,0x30,0x31,0x34,0x32,0x31,
-        0x31,0x34,0x32,0x32,0x31,0x34,0x32,0x33,
-        0x31,0x34,0x32,0x34,0x31,0x34,0x32,0x35,
-        0x31,0x34,0x32,0x36,0x31,0x34,0x32,0x37,
-        0x31,0x34,0x32,0x38,0x31,0x34,0x32,0x39,
-        0x31,0x34,0x33,0x30,0x31,0x34,0x33,0x31,
-        0x31,0x34,0x33,0x32,0x31,0x34,0x33,0x33,
-        0x31,0x34,0x33,0x34,0x31,0x34,0x33,0x35,
-        0x31,0x34,0x33,0x36,0x31,0x34,0x33,0x37,
-        0x31,0x34,0x33,0x38,0x31,0x34,0x33,0x39,
-        0x31,0x34,0x34,0x30,0x31,0x34,0x34,0x31,
-        0x31,0x34,0x34,0x32,0x31,0x34,0x34,0x33,
-        0x31,0x34,0x34,0x34,0x31,0x34,0x34,0x35,
-        0x31,0x34,0x34,0x36,0x31,0x34,0x34,0x37,
-        0x31,0x34,0x34,0x38,0x31,0x34,0x34,0x39,
-        0x31,0x34,0x35,0x30,0x31,0x34,0x35,0x31,
-        0x31,0x34,0x35,0x32,0x31,0x34,0x35,0x33,
-        0x31,0x34,0x35,0x34,0x31,0x34,0x35,0x35,
-        0x31,0x34,0x35,0x36,0x31,0x34,0x35,0x37,
-        0x31,0x34,0x35,0x38,0x31,0x34,0x35,0x39,
-        0x31,0x34,0x36,0x30,0x31,0x34,0x36,0x31,
-        0x31,0x34,0x36,0x32,0x31,0x34,0x36,0x33,
-        0x31,0x34,0x36,0x34,0x31,0x34,0x36,0x35,
-        0x31,0x34,0x36,0x36,0x31,0x34,0x36,0x37,
-        0x31,0x34,0x36,0x38,0x31,0x34,0x36,0x39,
-        0x31,0x34,0x37,0x30,0x31,0x34,0x37,0x31,
-        0x31,0x34,0x37,0x32,0x31,0x34,0x37,0x33,
-        0x31,0x34,0x37,0x34,0x31,0x34,0x37,0x35,
-        0x31,0x34,0x37,0x36,0x31,0x34,0x37,0x37,
-        0x31,0x34,0x37,0x38,0x31,0x34,0x37,0x39,
-        0x31,0x34,0x38,0x30,0x31,0x34,0x38,0x31,
-        0x31,0x34,0x38,0x32,0x31,0x34,0x38,0x33,
-        0x31,0x34,0x38,0x34,0x31,0x34,0x38,0x35,
-        0x31,0x34,0x38,0x36,0x31,0x34,0x38,0x37,
-        0x31,0x34,0x38,0x38,0x31,0x34,0x38,0x39,
-        0x31,0x34,0x39,0x30,0x31,0x34,0x39,0x31,
-        0x31,0x34,0x39,0x32,0x31,0x34,0x39,0x33,
-        0x31,0x34,0x39,0x34,0x31,0x34,0x39,0x35,
-        0x31,0x34,0x39,0x36,0x31,0x34,0x39,0x37,
-        0x31,0x34,0x39,0x38,0x31,0x34,0x39,0x39,
-        0x31,0x35,0x30,0x30,0x31,0x35,0x30,0x31,
-        0x31,0x35,0x30,0x32,0x31,0x35,0x30,0x33,
-        0x31,0x35,0x30,0x34,0x31,0x35,0x30,0x35,
-        0x31,0x35,0x30,0x36,0x31,0x35,0x30,0x37,
-        0x31,0x35,0x30,0x38,0x31,0x35,0x30,0x39,
-        0x31,0x35,0x31,0x30,0x31,0x35,0x31,0x31,
-        0x31,0x35,0x31,0x32,0x31,0x35,0x31,0x33,
-        0x31,0x35,0x31,0x34,0x31,0x35,0x31,0x35,
-        0x31,0x35,0x31,0x36,0x31,0x35,0x31,0x37,
-        0x31,0x35,0x31,0x38,0x31,0x35,0x31,0x39,
-        0x31,0x35,0x32,0x30,0x31,0x35,0x32,0x31,
-        0x31,0x35,0x32,0x32,0x31,0x35,0x32,0x33,
-        0x31,0x35,0x32,0x34,0x31,0x35,0x32,0x35,
-        0x31,0x35,0x32,0x36,0x31,0x35,0x32,0x37,
-        0x31,0x35,0x32,0x38,0x31,0x35,0x32,0x39,
-        0x31,0x35,0x33,0x30,0x31,0x35,0x33,0x31,
-        0x31,0x35,0x33,0x32,0x31,0x35,0x33,0x33,
-        0x31,0x35,0x33,0x34,0x31,0x35,0x33,0x35,
-        0x31,0x35,0x33,0x36,0x31,0x35,0x33,0x37,
-        0x31,0x35,0x33,0x38,0x31,0x35,0x33,0x39,
-        0x31,0x35,0x34,0x30,0x31,0x35,0x34,0x31,
-        0x31,0x35,0x34,0x32,0x31,0x35,0x34,0x33,
-        0x31,0x35,0x34,0x34,0x31,0x35,0x34,0x35,
-        0x31,0x35,0x34,0x36,0x31,0x35,0x34,0x37,
-        0x31,0x35,0x34,0x38,0x31,0x35,0x34,0x39,
-        0x31,0x35,0x35,0x30,0x31,0x35,0x35,0x31,
-        0x31,0x35,0x35,0x32,0x31,0x35,0x35,0x33,
-        0x31,0x35,0x35,0x34,0x31,0x35,0x35,0x35,
-        0x31,0x35,0x35,0x36,0x31,0x35,0x35,0x37,
-        0x31,0x35,0x35,0x38,0x31,0x35,0x35,0x39,
-        0x31,0x35,0x36,0x30,0x31,0x35,0x36,0x31,
-        0x31,0x35,0x36,0x32,0x31,0x35,0x36,0x33,
-        0x31,0x35,0x36,0x34,0x31,0x35,0x36,0x35,
-        0x31,0x35,0x36,0x36,0x31,0x35,0x36,0x37,
-        0x31,0x35,0x36,0x38,0x31,0x35,0x36,0x39,
-        0x31,0x35,0x37,0x30,0x31,0x35,0x37,0x31,
-        0x31,0x35,0x37,0x32,0x31,0x35,0x37,0x33,
-        0x31,0x35,0x37,0x34,0x31,0x35,0x37,0x35,
-        0x31,0x35,0x37,0x36,0x31,0x35,0x37,0x37,
-        0x31,0x35,0x37,0x38,0x31,0x35,0x37,0x39,
-        0x31,0x35,0x38,0x30,0x31,0x35,0x38,0x31,
-        0x31,0x35,0x38,0x32,0x31,0x35,0x38,0x33,
-        0x31,0x35,0x38,0x34,0x31,0x35,0x38,0x35,
-        0x31,0x35,0x38,0x36,0x31,0x35,0x38,0x37,
-        0x31,0x35,0x38,0x38,0x31,0x35,0x38,0x39,
-        0x31,0x35,0x39,0x30,0x31,0x35,0x39,0x31,
-        0x31,0x35,0x39,0x32,0x31,0x35,0x39,0x33,
-        0x31,0x35,0x39,0x34,0x31,0x35,0x39,0x35,
-        0x31,0x35,0x39,0x36,0x31,0x35,0x39,0x37,
-        0x31,0x35,0x39,0x38,0x31,0x35,0x39,0x39,
-        0x31,0x36,0x30,0x30,0x31,0x36,0x30,0x31,
-        0x31,0x36,0x30,0x32,0x31,0x36,0x30,0x33,
-        0x31,0x36,0x30,0x34,0x31,0x36,0x30,0x35,
-        0x31,0x36,0x30,0x36,0x31,0x36,0x30,0x37,
-        0x31,0x36,0x30,0x38,0x31,0x36,0x30,0x39,
-        0x31,0x36,0x31,0x30,0x31,0x36,0x31,0x31,
-        0x31,0x36,0x31,0x32,0x31,0x36,0x31,0x33,
-        0x31,0x36,0x31,0x34,0x31,0x36,0x31,0x35,
-        0x31,0x36,0x31,0x36,0x31,0x36,0x31,0x37,
-        0x31,0x36,0x31,0x38,0x31,0x36,0x31,0x39,
-        0x31,0x36,0x32,0x30,0x31,0x36,0x32,0x31,
-        0x31,0x36,0x32,0x32,0x31,0x36,0x32,0x33,
-        0x31,0x36,0x32,0x34,0x31,0x36,0x32,0x35,
-        0x31,0x36,0x32,0x36,0x31,0x36,0x32,0x37,
-        0x31,0x36,0x32,0x38,0x31,0x36,0x32,0x39,
-        0x31,0x36,0x33,0x30,0x31,0x36,0x33,0x31,
-        0x31,0x36,0x33,0x32,0x31,0x36,0x33,0x33,
-        0x31,0x36,0x33,0x34,0x31,0x36,0x33,0x35,
-        0x31,0x36,0x33,0x36,0x31,0x36,0x33,0x37,
-        0x31,0x36,0x33,0x38,0x31,0x36,0x33,0x39,
-        0x31,0x36,0x34,0x30,0x31,0x36,0x34,0x31,
-        0x31,0x36,0x34,0x32,0x31,0x36,0x34,0x33,
-        0x31,0x36,0x34,0x34,0x31,0x36,0x34,0x35,
-        0x31,0x36,0x34,0x36,0x31,0x36,0x34,0x37,
-        0x31,0x36,0x34,0x38,0x31,0x36,0x34,0x39,
-        0x31,0x36,0x35,0x30,0x31,0x36,0x35,0x31,
-        0x31,0x36,0x35,0x32,0x31,0x36,0x35,0x33,
-        0x31,0x36,0x35,0x34,0x31,0x36,0x35,0x35,
-        0x31,0x36,0x35,0x36,0x31,0x36,0x35,0x37,
-        0x31,0x36,0x35,0x38,0x31,0x36,0x35,0x39,
-        0x31,0x36,0x36,0x30,0x31,0x36,0x36,0x31,
-        0x31,0x36,0x36,0x32,0x31,0x36,0x36,0x33,
-        0x31,0x36,0x36,0x34,0x31,0x36,0x36,0x35,
-        0x31,0x36,0x36,0x36,0x31,0x36,0x36,0x37,
-        0x31,0x36,0x36,0x38,0x31,0x36,0x36,0x39,
-        0x31,0x36,0x37,0x30,0x31,0x36,0x37,0x31,
-        0x31,0x36,0x37,0x32,0x31,0x36,0x37,0x33,
-        0x31,0x36,0x37,0x34,0x31,0x36,0x37,0x35,
-        0x31,0x36,0x37,0x36,0x31,0x36,0x37,0x37,
-        0x31,0x36,0x37,0x38,0x31,0x36,0x37,0x39,
-        0x31,0x36,0x38,0x30,0x31,0x36,0x38,0x31,
-        0x31,0x36,0x38,0x32,0x31,0x36,0x38,0x33,
-        0x31,0x36,0x38,0x34,0x31,0x36,0x38,0x35,
-        0x31,0x36,0x38,0x36,0x31,0x36,0x38,0x37,
-        0x31,0x36,0x38,0x38,0x31,0x36,0x38,0x39,
-        0x31,0x36,0x39,0x30,0x31,0x36,0x39,0x31,
-        0x31,0x36,0x39,0x32,0x31,0x36,0x39,0x33,
-        0x31,0x36,0x39,0x34,0x31,0x36,0x39,0x35,
-        0x31,0x36,0x39,0x36,0x31,0x36,0x39,0x37,
-        0x31,0x36,0x39,0x38,0x31,0x36,0x39,0x39,
-        0x31,0x37,0x30,0x30,0x31,0x37,0x30,0x31,
-        0x31,0x37,0x30,0x32,0x31,0x37,0x30,0x33,
-        0x31,0x37,0x30,0x34,0x31,0x37,0x30,0x35,
-        0x31,0x37,0x30,0x36,0x31,0x37,0x30,0x37,
-        0x31,0x37,0x30,0x38,0x31,0x37,0x30,0x39,
-        0x31,0x37,0x31,0x30,0x31,0x37,0x31,0x31,
-        0x31,0x37,0x31,0x32,0x31,0x37,0x31,0x33,
-        0x31,0x37,0x31,0x34,0x31,0x37,0x31,0x35,
-        0x31,0x37,0x31,0x36,0x31,0x37,0x31,0x37,
-        0x31,0x37,0x31,0x38,0x31,0x37,0x31,0x39,
-        0x31,0x37,0x32,0x30,0x31,0x37,0x32,0x31,
-        0x31,0x37,0x32,0x32,0x31,0x37,0x32,0x33,
-        0x31,0x37,0x32,0x34,0x31,0x37,0x32,0x35,
-        0x31,0x37,0x32,0x36,0x31,0x37,0x32,0x37,
-        0x31,0x37,0x32,0x38,0x31,0x37,0x32,0x39,
-        0x31,0x37,0x33,0x30,0x31,0x37,0x33,0x31,
-        0x31,0x37,0x33,0x32,0x31,0x37,0x33,0x33,
-        0x31,0x37,0x33,0x34,0x31,0x37,0x33,0x35,
-        0x31,0x37,0x33,0x36,0x31,0x37,0x33,0x37,
-        0x31,0x37,0x33,0x38,0x31,0x37,0x33,0x39,
-        0x31,0x37,0x34,0x30,0x31,0x37,0x34,0x31,
-        0x31,0x37,0x34,0x32,0x31,0x37,0x34,0x33,
-        0x31,0x37,0x34,0x34,0x31,0x37,0x34,0x35,
-        0x31,0x37,0x34,0x36,0x31,0x37,0x34,0x37,
-        0x31,0x37,0x34,0x38,0x31,0x37,0x34,0x39,
-        0x31,0x37,0x35,0x30,0x31,0x37,0x35,0x31,
-        0x31,0x37,0x35,0x32,0x31,0x37,0x35,0x33,
-        0x31,0x37,0x35,0x34,0x31,0x37,0x35,0x35,
-        0x31,0x37,0x35,0x36,0x31,0x37,0x35,0x37,
-        0x31,0x37,0x35,0x38,0x31,0x37,0x35,0x39,
-        0x31,0x37,0x36,0x30,0x31,0x37,0x36,0x31,
-        0x31,0x37,0x36,0x32,0x31,0x37,0x36,0x33,
-        0x31,0x37,0x36,0x34,0x31,0x37,0x36,0x35,
-        0x31,0x37,0x36,0x36,0x31,0x37,0x36,0x37,
-        0x31,0x37,0x36,0x38,0x31,0x37,0x36,0x39,
-        0x31,0x37,0x37,0x30,0x31,0x37,0x37,0x31,
-        0x31,0x37,0x37,0x32,0x31,0x37,0x37,0x33,
-        0x31,0x37,0x37,0x34,0x31,0x37,0x37,0x35,
-        0x31,0x37,0x37,0x36,0x31,0x37,0x37,0x37,
-        0x31,0x37,0x37,0x38,0x31,0x37,0x37,0x39,
-        0x31,0x37,0x38,0x30,0x31,0x37,0x38,0x31,
-        0x31,0x37,0x38,0x32,0x31,0x37,0x38,0x33,
-        0x31,0x37,0x38,0x34,0x31,0x37,0x38,0x35,
-        0x31,0x37,0x38,0x36,0x31,0x37,0x38,0x37,
-        0x31,0x37,0x38,0x38,0x31,0x37,0x38,0x39,
-        0x31,0x37,0x39,0x30,0x31,0x37,0x39,0x31,
-        0x31,0x37,0x39,0x32,0x31,0x37,0x39,0x33,
-        0x31,0x37,0x39,0x34,0x31,0x37,0x39,0x35,
-        0x31,0x37,0x39,0x36,0x31,0x37,0x39,0x37,
-        0x31,0x37,0x39,0x38,0x31,0x37,0x39,0x39,
-        0x31,0x38,0x30,0x30,0x31,0x38,0x30,0x31,
-        0x31,0x38,0x30,0x32,0x31,0x38,0x30,0x33,
-        0x31,0x38,0x30,0x34,0x31,0x38,0x30,0x35,
-        0x31,0x38,0x30,0x36,0x31,0x38,0x30,0x37,
-        0x31,0x38,0x30,0x38,0x31,0x38,0x30,0x39,
-        0x31,0x38,0x31,0x30,0x31,0x38,0x31,0x31,
-        0x31,0x38,0x31,0x32,0x31,0x38,0x31,0x33,
-        0x31,0x38,0x31,0x34,0x31,0x38,0x31,0x35,
-        0x31,0x38,0x31,0x36,0x31,0x38,0x31,0x37,
-        0x31,0x38,0x31,0x38,0x31,0x38,0x31,0x39,
-        0x31,0x38,0x32,0x30,0x31,0x38,0x32,0x31,
-        0x31,0x38,0x32,0x32,0x31,0x38,0x32,0x33,
-        0x31,0x38,0x32,0x34,0x31,0x38,0x32,0x35,
-        0x31,0x38,0x32,0x36,0x31,0x38,0x32,0x37,
-        0x31,0x38,0x32,0x38,0x31,0x38,0x32,0x39,
-        0x31,0x38,0x33,0x30,0x31,0x38,0x33,0x31,
-        0x31,0x38,0x33,0x32,0x31,0x38,0x33,0x33,
-        0x31,0x38,0x33,0x34,0x31,0x38,0x33,0x35,
-        0x31,0x38,0x33,0x36,0x31,0x38,0x33,0x37,
-        0x31,0x38,0x33,0x38,0x31,0x38,0x33,0x39,
-        0x31,0x38,0x34,0x30,0x31,0x38,0x34,0x31,
-        0x31,0x38,0x34,0x32,0x31,0x38,0x34,0x33,
-        0x31,0x38,0x34,0x34,0x31,0x38,0x34,0x35,
-        0x31,0x38,0x34,0x36,0x31,0x38,0x34,0x37,
-        0x31,0x38,0x34,0x38,0x31,0x38,0x34,0x39,
-        0x31,0x38,0x35,0x30,0x31,0x38,0x35,0x31,
-        0x31,0x38,0x35,0x32,0x31,0x38,0x35,0x33,
-        0x31,0x38,0x35,0x34,0x31,0x38,0x35,0x35,
-        0x31,0x38,0x35,0x36,0x31,0x38,0x35,0x37,
-        0x31,0x38,0x35,0x38,0x31,0x38,0x35,0x39,
-        0x31,0x38,0x36,0x30,0x31,0x38,0x36,0x31,
-        0x31,0x38,0x36,0x32,0x31,0x38,0x36,0x33,
-        0x31,0x38,0x36,0x34,0x31,0x38,0x36,0x35,
-        0x31,0x38,0x36,0x36,0x31,0x38,0x36,0x37,
-        0x31,0x38,0x36,0x38,0x31,0x38,0x36,0x39,
-        0x31,0x38,0x37,0x30,0x31,0x38,0x37,0x31,
-        0x31,0x38,0x37,0x32,0x31,0x38,0x37,0x33,
-        0x31,0x38,0x37,0x34,0x31,0x38,0x37,0x35,
-        0x31,0x38,0x37,0x36,0x31,0x38,0x37,0x37,
-        0x31,0x38,0x37,0x38,0x31,0x38,0x37,0x39,
-        0x31,0x38,0x38,0x30,0x31,0x38,0x38,0x31,
-        0x31,0x38,0x38,0x32,0x31,0x38,0x38,0x33,
-        0x31,0x38,0x38,0x34,0x31,0x38,0x38,0x35,
-        0x31,0x38,0x38,0x36,0x31,0x38,0x38,0x37,
-        0x31,0x38,0x38,0x38,0x31,0x38,0x38,0x39,
-        0x31,0x38,0x39,0x30,0x31,0x38,0x39,0x31,
-        0x31,0x38,0x39,0x32,0x31,0x38,0x39,0x33,
-        0x31,0x38,0x39,0x34,0x31,0x38,0x39,0x35,
-        0x31,0x38,0x39,0x36,0x31,0x38,0x39,0x37,
-        0x31,0x38,0x39,0x38,0x31,0x38,0x39,0x39,
-        0x31,0x39,0x30,0x30,0x31,0x39,0x30,0x31,
-        0x31,0x39,0x30,0x32,0x31,0x39,0x30,0x33,
-        0x31,0x39,0x30,0x34,0x31,0x39,0x30,0x35,
-        0x31,0x39,0x30,0x36,0x31,0x39,0x30,0x37,
-        0x31,0x39,0x30,0x38,0x31,0x39,0x30,0x39,
-        0x31,0x39,0x31,0x30,0x31,0x39,0x31,0x31,
-        0x31,0x39,0x31,0x32,0x31,0x39,0x31,0x33,
-        0x31,0x39,0x31,0x34,0x31,0x39,0x31,0x35,
-        0x31,0x39,0x31,0x36,0x31,0x39,0x31,0x37,
-        0x31,0x39,0x31,0x38,0x31,0x39,0x31,0x39,
-        0x31,0x39,0x32,0x30,0x31,0x39,0x32,0x31,
-        0x31,0x39,0x32,0x32,0x31,0x39,0x32,0x33,
-        0x31,0x39,0x32,0x34,0x31,0x39,0x32,0x35,
-        0x31,0x39,0x32,0x36,0x31,0x39,0x32,0x37,
-        0x31,0x39,0x32,0x38,0x31,0x39,0x32,0x39,
-        0x31,0x39,0x33,0x30,0x31,0x39,0x33,0x31,
-        0x31,0x39,0x33,0x32,0x31,0x39,0x33,0x33,
-        0x31,0x39,0x33,0x34,0x31,0x39,0x33,0x35,
-        0x31,0x39,0x33,0x36,0x31,0x39,0x33,0x37,
-        0x31,0x39,0x33,0x38,0x31,0x39,0x33,0x39,
-        0x31,0x39,0x34,0x30,0x31,0x39,0x34,0x31,
-        0x31,0x39,0x34,0x32,0x31,0x39,0x34,0x33,
-        0x31,0x39,0x34,0x34,0x31,0x39,0x34,0x35,
-        0x31,0x39,0x34,0x36,0x31,0x39,0x34,0x37,
-        0x31,0x39,0x34,0x38,0x31,0x39,0x34,0x39,
-        0x31,0x39,0x35,0x30,0x31,0x39,0x35,0x31,
-        0x31,0x39,0x35,0x32,0x31,0x39,0x35,0x33,
-        0x31,0x39,0x35,0x34,0x31,0x39,0x35,0x35,
-        0x31,0x39,0x35,0x36,0x31,0x39,0x35,0x37,
-        0x31,0x39,0x35,0x38,0x31,0x39,0x35,0x39,
-        0x31,0x39,0x36,0x30,0x31,0x39,0x36,0x31,
-        0x31,0x39,0x36,0x32,0x31,0x39,0x36,0x33,
-        0x31,0x39,0x36,0x34,0x31,0x39,0x36,0x35,
-        0x31,0x39,0x36,0x36,0x31,0x39,0x36,0x37,
-        0x31,0x39,0x36,0x38,0x31,0x39,0x36,0x39,
-        0x31,0x39,0x37,0x30,0x31,0x39,0x37,0x31,
-        0x31,0x39,0x37,0x32,0x31,0x39,0x37,0x33,
-        0x31,0x39,0x37,0x34,0x31,0x39,0x37,0x35,
-        0x31,0x39,0x37,0x36,0x31,0x39,0x37,0x37,
-        0x31,0x39,0x37,0x38,0x31,0x39,0x37,0x39,
-        0x31,0x39,0x38,0x30,0x31,0x39,0x38,0x31,
-        0x31,0x39,0x38,0x32,0x31,0x39,0x38,0x33,
-        0x31,0x39,0x38,0x34,0x31,0x39,0x38,0x35,
-        0x31,0x39,0x38,0x36,0x31,0x39,0x38,0x37,
-        0x31,0x39,0x38,0x38,0x31,0x39,0x38,0x39,
-        0x31,0x39,0x39,0x30,0x31,0x39,0x39,0x31,
-        0x31,0x39,0x39,0x32,0x31,0x39,0x39,0x33,
-        0x31,0x39,0x39,0x34,0x31,0x39,0x39,0x35,
-        0x31,0x39,0x39,0x36,0x31,0x39,0x39,0x37,
-        0x31,0x39,0x39,0x38,0x31,0x39,0x39,0x39,
-        0x32,0x30,0x30,0x30,0x32,0x30,0x30,0x31,
-        0x32,0x30,0x30,0x32,0x32,0x30,0x30,0x33,
-        0x32,0x30,0x30,0x34,0x32,0x30,0x30,0x35,
-        0x32,0x30,0x30,0x36,0x32,0x30,0x30,0x37,
-        0x32,0x30,0x30,0x38,0x32,0x30,0x30,0x39,
-        0x32,0x30,0x31,0x30,0x32,0x30,0x31,0x31,
-        0x32,0x30,0x31,0x32,0x32,0x30,0x31,0x33,
-        0x32,0x30,0x31,0x34,0x32,0x30,0x31,0x35,
-        0x32,0x30,0x31,0x36,0x32,0x30,0x31,0x37,
-        0x32,0x30,0x31,0x38,0x32,0x30,0x31,0x39,
-        0x32,0x30,0x32,0x30,0x32,0x30,0x32,0x31,
-        0x32,0x30,0x32,0x32,0x32,0x30,0x32,0x33,
-        0x32,0x30,0x32,0x34,0x32,0x30,0x32,0x35,
-        0x32,0x30,0x32,0x36,0x32,0x30,0x32,0x37,
-        0x32,0x30,0x32,0x38,0x32,0x30,0x32,0x39,
-        0x32,0x30,0x33,0x30,0x32,0x30,0x33,0x31,
-        0x32,0x30,0x33,0x32,0x32,0x30,0x33,0x33,
-        0x32,0x30,0x33,0x34,0x32,0x30,0x33,0x35,
-        0x32,0x30,0x33,0x36,0x32,0x30,0x33,0x37,
-        0x32,0x30,0x33,0x38,0x32,0x30,0x33,0x39,
-        0x32,0x30,0x34,0x30,0x32,0x30,0x34,0x31,
-        0x32,0x30,0x34,0x32,0x32,0x30,0x34,0x33,
-        0x32,0x30,0x34,0x34,0x32,0x30,0x34,0x35,
-        0x32,0x30,0x34,0x36,0x32,0x30,0x34,0x37,
-        0x32,0x30,0x34,0x38,0x32,0x30,0x34,0x39,
-        0x32,0x30,0x35,0x30,0x32,0x30,0x35,0x31,
-        0x32,0x30,0x35,0x32,0x32,0x30,0x35,0x33,
-        0x32,0x30,0x35,0x34,0x32,0x30,0x35,0x35,
-        0x32,0x30,0x35,0x36,0x32,0x30,0x35,0x37,
-        0x32,0x30,0x35,0x38,0x32,0x30,0x35,0x39,
-        0x32,0x30,0x36,0x30,0x32,0x30,0x36,0x31,
-        0x32,0x30,0x36,0x32,0x32,0x30,0x36,0x33,
-        0x32,0x30,0x36,0x34,0x32,0x30,0x36,0x35,
-        0x32,0x30,0x36,0x36,0x32,0x30,0x36,0x37,
-        0x32,0x30,0x36,0x38,0x32,0x30,0x36,0x39,
-        0x32,0x30,0x37,0x30,0x32,0x30,0x37,0x31,
-        0x32,0x30,0x37,0x32,0x32,0x30,0x37,0x33,
-        0x32,0x30,0x37,0x34,0x32,0x30,0x37,0x35,
-        0x32,0x30,0x37,0x36,0x32,0x30,0x37,0x37,
-        0x32,0x30,0x37,0x38,0x32,0x30,0x37,0x39,
-        0x32,0x30,0x38,0x30,0x32,0x30,0x38,0x31,
-        0x32,0x30,0x38,0x32,0x32,0x30,0x38,0x33,
-        0x32,0x30,0x38,0x34,0x32,0x30,0x38,0x35,
-        0x32,0x30,0x38,0x36,0x32,0x30,0x38,0x37,
-        0x32,0x30,0x38,0x38,0x32,0x30,0x38,0x39,
-        0x32,0x30,0x39,0x30,0x32,0x30,0x39,0x31,
-        0x32,0x30,0x39,0x32,0x32,0x30,0x39,0x33,
-        0x32,0x30,0x39,0x34,0x32,0x30,0x39,0x35,
-        0x32,0x30,0x39,0x36,0x32,0x30,0x39,0x37,
-        0x32,0x30,0x39,0x38,0x32,0x30,0x39,0x39,
-        0x32,0x31,0x30,0x30,0x32,0x31,0x30,0x31,
-        0x32,0x31,0x30,0x32,0x32,0x31,0x30,0x33,
-        0x32,0x31,0x30,0x34,0x32,0x31,0x30,0x35,
-        0x32,0x31,0x30,0x36,0x32,0x31,0x30,0x37,
-        0x32,0x31,0x30,0x38,0x32,0x31,0x30,0x39,
-        0x32,0x31,0x31,0x30,0x32,0x31,0x31,0x31,
-        0x32,0x31,0x31,0x32,0x32,0x31,0x31,0x33,
-        0x32,0x31,0x31,0x34,0x32,0x31,0x31,0x35,
-        0x32,0x31,0x31,0x36,0x32,0x31,0x31,0x37,
-        0x32,0x31,0x31,0x38,0x32,0x31,0x31,0x39,
-        0x32,0x31,0x32,0x30,0x32,0x31,0x32,0x31,
-        0x32,0x31,0x32,0x32,0x32,0x31,0x32,0x33,
-        0x32,0x31,0x32,0x34,0x32,0x31,0x32,0x35,
-        0x32,0x31,0x32,0x36,0x32,0x31,0x32,0x37,
-        0x32,0x31,0x32,0x38,0x32,0x31,0x32,0x39,
-        0x32,0x31,0x33,0x30,0x32,0x31,0x33,0x31,
-        0x32,0x31,0x33,0x32,0x32,0x31,0x33,0x33,
-        0x32,0x31,0x33,0x34,0x32,0x31,0x33,0x35,
-        0x32,0x31,0x33,0x36,0x32,0x31,0x33,0x37,
-        0x32,0x31,0x33,0x38,0x32,0x31,0x33,0x39,
-        0x32,0x31,0x34,0x30,0x32,0x31,0x34,0x31,
-        0x32,0x31,0x34,0x32,0x32,0x31,0x34,0x33,
-        0x32,0x31,0x34,0x34,0x32,0x31,0x34,0x35,
-        0x32,0x31,0x34,0x36,0x32,0x31,0x34,0x37,
-        0x32,0x31,0x34,0x38,0x32,0x31,0x34,0x39,
-        0x32,0x31,0x35,0x30,0x32,0x31,0x35,0x31,
-        0x32,0x31,0x35,0x32,0x32,0x31,0x35,0x33,
-        0x32,0x31,0x35,0x34,0x32,0x31,0x35,0x35,
-        0x32,0x31,0x35,0x36,0x32,0x31,0x35,0x37,
-        0x32,0x31,0x35,0x38,0x32,0x31,0x35,0x39,
-        0x32,0x31,0x36,0x30,0x32,0x31,0x36,0x31,
-        0x32,0x31,0x36,0x32,0x32,0x31,0x36,0x33,
-        0x32,0x31,0x36,0x34,0x32,0x31,0x36,0x35,
-        0x32,0x31,0x36,0x36,0x32,0x31,0x36,0x37,
-        0x32,0x31,0x36,0x38,0x32,0x31,0x36,0x39,
-        0x32,0x31,0x37,0x30,0x32,0x31,0x37,0x31,
-        0x32,0x31,0x37,0x32,0x32,0x31,0x37,0x33,
-        0x32,0x31,0x37,0x34,0x32,0x31,0x37,0x35,
-        0x32,0x31,0x37,0x36,0x32,0x31,0x37,0x37,
-        0x32,0x31,0x37,0x38,0x32,0x31,0x37,0x39,
-        0x32,0x31,0x38,0x30,0x32,0x31,0x38,0x31,
-        0x32,0x31,0x38,0x32,0x32,0x31,0x38,0x33,
-        0x32,0x31,0x38,0x34,0x32,0x31,0x38,0x35,
-        0x32,0x31,0x38,0x36,0x32,0x31,0x38,0x37,
-        0x32,0x31,0x38,0x38,0x32,0x31,0x38,0x39,
-        0x32,0x31,0x39,0x30,0x32,0x31,0x39,0x31,
-        0x32,0x31,0x39,0x32,0x32,0x31,0x39,0x33,
-        0x32,0x31,0x39,0x34,0x32,0x31,0x39,0x35,
-        0x32,0x31,0x39,0x36,0x32,0x31,0x39,0x37,
-        0x32,0x31,0x39,0x38,0x32,0x31,0x39,0x39,
-        0x32,0x32,0x30,0x30,0x32,0x32,0x30,0x31,
-        0x32,0x32,0x30,0x32,0x32,0x32,0x30,0x33,
-        0x32,0x32,0x30,0x34,0x32,0x32,0x30,0x35,
-        0x32,0x32,0x30,0x36,0x32,0x32,0x30,0x37,
-        0x32,0x32,0x30,0x38,0x32,0x32,0x30,0x39,
-        0x32,0x32,0x31,0x30,0x32,0x32,0x31,0x31,
-        0x32,0x32,0x31,0x32,0x32,0x32,0x31,0x33,
-        0x32,0x32,0x31,0x34,0x32,0x32,0x31,0x35,
-        0x32,0x32,0x31,0x36,0x32,0x32,0x31,0x37,
-        0x32,0x32,0x31,0x38,0x32,0x32,0x31,0x39,
-        0x32,0x32,0x32,0x30,0x32,0x32,0x32,0x31,
-        0x32,0x32,0x32,0x32,0x32,0x32,0x32,0x33,
-        0x32,0x32,0x32,0x34,0x32,0x32,0x32,0x35,
-        0x32,0x32,0x32,0x36,0x32,0x32,0x32,0x37,
-        0x32,0x32,0x32,0x38,0x32,0x32,0x32,0x39,
-        0x32,0x32,0x33,0x30,0x32,0x32,0x33,0x31,
-        0x32,0x32,0x33,0x32,0x32,0x32,0x33,0x33,
-        0x32,0x32,0x33,0x34,0x32,0x32,0x33,0x35,
-        0x32,0x32,0x33,0x36,0x32,0x32,0x33,0x37,
-        0x32,0x32,0x33,0x38,0x32,0x32,0x33,0x39,
-        0x32,0x32,0x34,0x30,0x32,0x32,0x34,0x31,
-        0x32,0x32,0x34,0x32,0x32,0x32,0x34,0x33,
-        0x32,0x32,0x34,0x34,0x32,0x32,0x34,0x35,
-        0x32,0x32,0x34,0x36,0x32,0x32,0x34,0x37,
-        0x32,0x32,0x34,0x38,0x32,0x32,0x34,0x39,
-        0x32,0x32,0x35,0x30,0x32,0x32,0x35,0x31,
-        0x32,0x32,0x35,0x32,0x32,0x32,0x35,0x33,
-        0x32,0x32,0x35,0x34,0x32,0x32,0x35,0x35,
-        0x32,0x32,0x35,0x36,0x32,0x32,0x35,0x37,
-        0x32,0x32,0x35,0x38,0x32,0x32,0x35,0x39,
-        0x32,0x32,0x36,0x30,0x32,0x32,0x36,0x31,
-        0x32,0x32,0x36,0x32,0x32,0x32,0x36,0x33,
-        0x32,0x32,0x36,0x34,0x32,0x32,0x36,0x35,
-        0x32,0x32,0x36,0x36,0x32,0x32,0x36,0x37,
-        0x32,0x32,0x36,0x38,0x32,0x32,0x36,0x39,
-        0x32,0x32,0x37,0x30,0x32,0x32,0x37,0x31,
-        0x32,0x32,0x37,0x32,0x32,0x32,0x37,0x33,
-        0x32,0x32,0x37,0x34,0x32,0x32,0x37,0x35,
-        0x32,0x32,0x37,0x36,0x32,0x32,0x37,0x37,
-        0x32,0x32,0x37,0x38,0x32,0x32,0x37,0x39,
-        0x32,0x32,0x38,0x30,0x32,0x32,0x38,0x31,
-        0x32,0x32,0x38,0x32,0x32,0x32,0x38,0x33,
-        0x32,0x32,0x38,0x34,0x32,0x32,0x38,0x35,
-        0x32,0x32,0x38,0x36,0x32,0x32,0x38,0x37,
-        0x32,0x32,0x38,0x38,0x32,0x32,0x38,0x39,
-        0x32,0x32,0x39,0x30,0x32,0x32,0x39,0x31,
-        0x32,0x32,0x39,0x32,0x32,0x32,0x39,0x33,
-        0x32,0x32,0x39,0x34,0x32,0x32,0x39,0x35,
-        0x32,0x32,0x39,0x36,0x32,0x32,0x39,0x37,
-        0x32,0x32,0x39,0x38,0x32,0x32,0x39,0x39,
-        0x32,0x33,0x30,0x30,0x32,0x33,0x30,0x31,
-        0x32,0x33,0x30,0x32,0x32,0x33,0x30,0x33,
-        0x32,0x33,0x30,0x34,0x32,0x33,0x30,0x35,
-        0x32,0x33,0x30,0x36,0x32,0x33,0x30,0x37,
-        0x32,0x33,0x30,0x38,0x32,0x33,0x30,0x39,
-        0x32,0x33,0x31,0x30,0x32,0x33,0x31,0x31,
-        0x32,0x33,0x31,0x32,0x32,0x33,0x31,0x33,
-        0x32,0x33,0x31,0x34,0x32,0x33,0x31,0x35,
-        0x32,0x33,0x31,0x36,0x32,0x33,0x31,0x37,
-        0x32,0x33,0x31,0x38,0x32,0x33,0x31,0x39,
-        0x32,0x33,0x32,0x30,0x32,0x33,0x32,0x31,
-        0x32,0x33,0x32,0x32,0x32,0x33,0x32,0x33,
-        0x32,0x33,0x32,0x34,0x32,0x33,0x32,0x35,
-        0x32,0x33,0x32,0x36,0x32,0x33,0x32,0x37,
-        0x32,0x33,0x32,0x38,0x32,0x33,0x32,0x39,
-        0x32,0x33,0x33,0x30,0x32,0x33,0x33,0x31,
-        0x32,0x33,0x33,0x32,0x32,0x33,0x33,0x33,
-        0x32,0x33,0x33,0x34,0x32,0x33,0x33,0x35,
-        0x32,0x33,0x33,0x36,0x32,0x33,0x33,0x37,
-        0x32,0x33,0x33,0x38,0x32,0x33,0x33,0x39,
-        0x32,0x33,0x34,0x30,0x32,0x33,0x34,0x31,
-        0x32,0x33,0x34,0x32,0x32,0x33,0x34,0x33,
-        0x32,0x33,0x34,0x34,0x32,0x33,0x34,0x35,
-        0x32,0x33,0x34,0x36,0x32,0x33,0x34,0x37,
-        0x32,0x33,0x34,0x38,0x32,0x33,0x34,0x39,
-        0x32,0x33,0x35,0x30,0x32,0x33,0x35,0x31,
-        0x32,0x33,0x35,0x32,0x32,0x33,0x35,0x33,
-        0x32,0x33,0x35,0x34,0x32,0x33,0x35,0x35,
-        0x32,0x33,0x35,0x36,0x32,0x33,0x35,0x37,
-        0x32,0x33,0x35,0x38,0x32,0x33,0x35,0x39,
-        0x32,0x33,0x36,0x30,0x32,0x33,0x36,0x31,
-        0x32,0x33,0x36,0x32,0x32,0x33,0x36,0x33,
-        0x32,0x33,0x36,0x34,0x32,0x33,0x36,0x35,
-        0x32,0x33,0x36,0x36,0x32,0x33,0x36,0x37,
-        0x32,0x33,0x36,0x38,0x32,0x33,0x36,0x39,
-        0x32,0x33,0x37,0x30,0x32,0x33,0x37,0x31,
-        0x32,0x33,0x37,0x32,0x32,0x33,0x37,0x33,
-        0x32,0x33,0x37,0x34,0x32,0x33,0x37,0x35,
-        0x32,0x33,0x37,0x36,0x32,0x33,0x37,0x37,
-        0x32,0x33,0x37,0x38,0x32,0x33,0x37,0x39,
-        0x32,0x33,0x38,0x30,0x32,0x33,0x38,0x31,
-        0x32,0x33,0x38,0x32,0x32,0x33,0x38,0x33,
-        0x32,0x33,0x38,0x34,0x32,0x33,0x38,0x35,
-        0x32,0x33,0x38,0x36,0x32,0x33,0x38,0x37,
-        0x32,0x33,0x38,0x38,0x32,0x33,0x38,0x39,
-        0x32,0x33,0x39,0x30,0x32,0x33,0x39,0x31,
-        0x32,0x33,0x39,0x32,0x32,0x33,0x39,0x33,
-        0x32,0x33,0x39,0x34,0x32,0x33,0x39,0x35,
-        0x32,0x33,0x39,0x36,0x32,0x33,0x39,0x37,
-        0x32,0x33,0x39,0x38,0x32,0x33,0x39,0x39,
-        0x32,0x34,0x30,0x30,0x32,0x34,0x30,0x31,
-        0x32,0x34,0x30,0x32,0x32,0x34,0x30,0x33,
-        0x32,0x34,0x30,0x34,0x32,0x34,0x30,0x35,
-        0x32,0x34,0x30,0x36,0x32,0x34,0x30,0x37,
-        0x32,0x34,0x30,0x38,0x32,0x34,0x30,0x39,
-        0x32,0x34,0x31,0x30,0x32,0x34,0x31,0x31,
-        0x32,0x34,0x31,0x32,0x32,0x34,0x31,0x33,
-        0x32,0x34,0x31,0x34,0x32,0x34,0x31,0x35,
-        0x32,0x34,0x31,0x36,0x32,0x34,0x31,0x37,
-        0x32,0x34,0x31,0x38,0x32,0x34,0x31,0x39,
-        0x32,0x34,0x32,0x30,0x32,0x34,0x32,0x31,
-        0x32,0x34,0x32,0x32,0x32,0x34,0x32,0x33,
-        0x32,0x34,0x32,0x34,0x32,0x34,0x32,0x35,
-        0x32,0x34,0x32,0x36,0x32,0x34,0x32,0x37,
-        0x32,0x34,0x32,0x38,0x32,0x34,0x32,0x39,
-        0x32,0x34,0x33,0x30,0x32,0x34,0x33,0x31,
-        0x32,0x34,0x33,0x32,0x32,0x34,0x33,0x33,
-        0x32,0x34,0x33,0x34,0x32,0x34,0x33,0x35,
-        0x32,0x34,0x33,0x36,0x32,0x34,0x33,0x37,
-        0x32,0x34,0x33,0x38,0x32,0x34,0x33,0x39,
-        0x32,0x34,0x34,0x30,0x32,0x34,0x34,0x31,
-        0x32,0x34,0x34,0x32,0x32,0x34,0x34,0x33,
-        0x32,0x34,0x34,0x34,0x32,0x34,0x34,0x35,
-        0x32,0x34,0x34,0x36,0x32,0x34,0x34,0x37,
-        0x32,0x34,0x34,0x38,0x32,0x34,0x34,0x39,
-        0x32,0x34,0x35,0x30,0x32,0x34,0x35,0x31,
-        0x32,0x34,0x35,0x32,0x32,0x34,0x35,0x33,
-        0x32,0x34,0x35,0x34,0x32,0x34,0x35,0x35,
-        0x32,0x34,0x35,0x36,0x32,0x34,0x35,0x37,
-        0x32,0x34,0x35,0x38,0x32,0x34,0x35,0x39,
-        0x32,0x34,0x36,0x30,0x32,0x34,0x36,0x31,
-        0x32,0x34,0x36,0x32,0x32,0x34,0x36,0x33,
-        0x32,0x34,0x36,0x34,0x32,0x34,0x36,0x35,
-        0x32,0x34,0x36,0x36,0x32,0x34,0x36,0x37,
-        0x32,0x34,0x36,0x38,0x32,0x34,0x36,0x39,
-        0x32,0x34,0x37,0x30,0x32,0x34,0x37,0x31,
-        0x32,0x34,0x37,0x32,0x32,0x34,0x37,0x33,
-        0x32,0x34,0x37,0x34,0x32,0x34,0x37,0x35,
-        0x32,0x34,0x37,0x36,0x32,0x34,0x37,0x37,
-        0x32,0x34,0x37,0x38,0x32,0x34,0x37,0x39,
-        0x32,0x34,0x38,0x30,0x32,0x34,0x38,0x31,
-        0x32,0x34,0x38,0x32,0x32,0x34,0x38,0x33,
-        0x32,0x34,0x38,0x34,0x32,0x34,0x38,0x35,
-        0x32,0x34,0x38,0x36,0x32,0x34,0x38,0x37,
-        0x32,0x34,0x38,0x38,0x32,0x34,0x38,0x39,
-        0x32,0x34,0x39,0x30,0x32,0x34,0x39,0x31,
-        0x32,0x34,0x39,0x32,0x32,0x34,0x39,0x33,
-        0x32,0x34,0x39,0x34,0x32,0x34,0x39,0x35,
-        0x32,0x34,0x39,0x36,0x32,0x34,0x39,0x37,
-        0x32,0x34,0x39,0x38,0x32,0x34,0x39,0x39,
-        0x32,0x35,0x30,0x30,0x32,0x35,0x30,0x31,
-        0x32,0x35,0x30,0x32,0x32,0x35,0x30,0x33,
-        0x32,0x35,0x30,0x34,0x32,0x35,0x30,0x35,
-        0x32,0x35,0x30,0x36,0x32,0x35,0x30,0x37,
-        0x32,0x35,0x30,0x38,0x32,0x35,0x30,0x39,
-        0x32,0x35,0x31,0x30,0x32,0x35,0x31,0x31,
-        0x32,0x35,0x31,0x32,0x32,0x35,0x31,0x33,
-        0x32,0x35,0x31,0x34,0x32,0x35,0x31,0x35,
-        0x32,0x35,0x31,0x36,0x32,0x35,0x31,0x37,
-        0x32,0x35,0x31,0x38,0x32,0x35,0x31,0x39,
-        0x32,0x35,0x32,0x30,0x32,0x35,0x32,0x31,
-        0x32,0x35,0x32,0x32,0x32,0x35,0x32,0x33,
-        0x32,0x35,0x32,0x34,0x32,0x35,0x32,0x35,
-        0x32,0x35,0x32,0x36,0x32,0x35,0x32,0x37,
-        0x32,0x35,0x32,0x38,0x32,0x35,0x32,0x39,
-        0x32,0x35,0x33,0x30,0x32,0x35,0x33,0x31,
-        0x32,0x35,0x33,0x32,0x32,0x35,0x33,0x33,
-        0x32,0x35,0x33,0x34,0x32,0x35,0x33,0x35,
-        0x32,0x35,0x33,0x36,0x32,0x35,0x33,0x37,
-        0x32,0x35,0x33,0x38,0x32,0x35,0x33,0x39,
-        0x32,0x35,0x34,0x30,0x32,0x35,0x34,0x31,
-        0x32,0x35,0x34,0x32,0x32,0x35,0x34,0x33,
-        0x32,0x35,0x34,0x34,0x32,0x35,0x34,0x35,
-        0x32,0x35,0x34,0x36,0x32,0x35,0x34,0x37,
-        0x32,0x35,0x34,0x38,0x32,0x35,0x34,0x39,
-        0x32,0x35,0x35,0x30,0x32,0x35,0x35,0x31,
-        0x32,0x35,0x35,0x32,0x32,0x35,0x35,0x33,
-        0x32,0x35,0x35,0x34,0x32,0x35,0x35,0x35,
-        0x32,0x35,0x35,0x36,0x32,0x35,0x35,0x37,
-        0x32,0x35,0x35,0x38,0x32,0x35,0x35,0x39,
-        0x32,0x35,0x36,0x30,0x32,0x35,0x36,0x31,
-        0x32,0x35,0x36,0x32,0x32,0x35,0x36,0x33,
-        0x32,0x35,0x36,0x34,0x32,0x35,0x36,0x35,
-        0x32,0x35,0x36,0x36,0x32,0x35,0x36,0x37,
-        0x32,0x35,0x36,0x38,0x32,0x35,0x36,0x39,
-        0x32,0x35,0x37,0x30,0x32,0x35,0x37,0x31,
-        0x32,0x35,0x37,0x32,0x32,0x35,0x37,0x33,
-        0x32,0x35,0x37,0x34,0x32,0x35,0x37,0x35,
-        0x32,0x35,0x37,0x36,0x32,0x35,0x37,0x37,
-        0x32,0x35,0x37,0x38,0x32,0x35,0x37,0x39,
-        0x32,0x35,0x38,0x30,0x32,0x35,0x38,0x31,
-        0x32,0x35,0x38,0x32,0x32,0x35,0x38,0x33,
-        0x32,0x35,0x38,0x34,0x32,0x35,0x38,0x35,
-        0x32,0x35,0x38,0x36,0x32,0x35,0x38,0x37,
-        0x32,0x35,0x38,0x38,0x32,0x35,0x38,0x39,
-        0x32,0x35,0x39,0x30,0x32,0x35,0x39,0x31,
-        0x32,0x35,0x39,0x32,0x32,0x35,0x39,0x33,
-        0x32,0x35,0x39,0x34,0x32,0x35,0x39,0x35,
-        0x32,0x35,0x39,0x36,0x32,0x35,0x39,0x37,
-        0x32,0x35,0x39,0x38,0x32,0x35,0x39,0x39,
-        0x32,0x36,0x30,0x30,0x32,0x36,0x30,0x31,
-        0x32,0x36,0x30,0x32,0x32,0x36,0x30,0x33,
-        0x32,0x36,0x30,0x34,0x32,0x36,0x30,0x35,
-        0x32,0x36,0x30,0x36,0x32,0x36,0x30,0x37,
-        0x32,0x36,0x30,0x38,0x32,0x36,0x30,0x39,
-        0x32,0x36,0x31,0x30,0x32,0x36,0x31,0x31,
-        0x32,0x36,0x31,0x32,0x32,0x36,0x31,0x33,
-        0x32,0x36,0x31,0x34,0x32,0x36,0x31,0x35,
-        0x32,0x36,0x31,0x36,0x32,0x36,0x31,0x37,
-        0x32,0x36,0x31,0x38,0x32,0x36,0x31,0x39,
-        0x32,0x36,0x32,0x30,0x32,0x36,0x32,0x31,
-        0x32,0x36,0x32,0x32,0x32,0x36,0x32,0x33,
-        0x32,0x36,0x32,0x34,0x32,0x36,0x32,0x35,
-        0x32,0x36,0x32,0x36,0x32,0x36,0x32,0x37,
-        0x32,0x36,0x32,0x38,0x32,0x36,0x32,0x39,
-        0x32,0x36,0x33,0x30,0x32,0x36,0x33,0x31,
-        0x32,0x36,0x33,0x32,0x32,0x36,0x33,0x33,
-        0x32,0x36,0x33,0x34,0x32,0x36,0x33,0x35,
-        0x32,0x36,0x33,0x36,0x32,0x36,0x33,0x37,
-        0x32,0x36,0x33,0x38,0x32,0x36,0x33,0x39,
-        0x32,0x36,0x34,0x30,0x32,0x36,0x34,0x31,
-        0x32,0x36,0x34,0x32,0x32,0x36,0x34,0x33,
-        0x32,0x36,0x34,0x34,0x32,0x36,0x34,0x35,
-        0x32,0x36,0x34,0x36,0x32,0x36,0x34,0x37,
-        0x32,0x36,0x34,0x38,0x32,0x36,0x34,0x39,
-        0x32,0x36,0x35,0x30,0x32,0x36,0x35,0x31,
-        0x32,0x36,0x35,0x32,0x32,0x36,0x35,0x33,
-        0x32,0x36,0x35,0x34,0x32,0x36,0x35,0x35,
-        0x32,0x36,0x35,0x36,0x32,0x36,0x35,0x37,
-        0x32,0x36,0x35,0x38,0x32,0x36,0x35,0x39,
-        0x32,0x36,0x36,0x30,0x32,0x36,0x36,0x31,
-        0x32,0x36,0x36,0x32,0x32,0x36,0x36,0x33,
-        0x32,0x36,0x36,0x34,0x32,0x36,0x36,0x35,
-        0x32,0x36,0x36,0x36,0x32,0x36,0x36,0x37,
-        0x32,0x36,0x36,0x38,0x32,0x36,0x36,0x39,
-        0x32,0x36,0x37,0x30,0x32,0x36,0x37,0x31,
-        0x32,0x36,0x37,0x32,0x32,0x36,0x37,0x33,
-        0x32,0x36,0x37,0x34,0x32,0x36,0x37,0x35,
-        0x32,0x36,0x37,0x36,0x32,0x36,0x37,0x37,
-        0x32,0x36,0x37,0x38,0x32,0x36,0x37,0x39,
-        0x32,0x36,0x38,0x30,0x32,0x36,0x38,0x31,
-        0x32,0x36,0x38,0x32,0x32,0x36,0x38,0x33,
-        0x32,0x36,0x38,0x34,0x32,0x36,0x38,0x35,
-        0x32,0x36,0x38,0x36,0x32,0x36,0x38,0x37,
-        0x32,0x36,0x38,0x38,0x32,0x36,0x38,0x39,
-        0x32,0x36,0x39,0x30,0x32,0x36,0x39,0x31,
-        0x32,0x36,0x39,0x32,0x32,0x36,0x39,0x33,
-        0x32,0x36,0x39,0x34,0x32,0x36,0x39,0x35,
-        0x32,0x36,0x39,0x36,0x32,0x36,0x39,0x37,
-        0x32,0x36,0x39,0x38,0x32,0x36,0x39,0x39,
-        0x32,0x37,0x30,0x30,0x32,0x37,0x30,0x31,
-        0x32,0x37,0x30,0x32,0x32,0x37,0x30,0x33,
-        0x32,0x37,0x30,0x34,0x32,0x37,0x30,0x35,
-        0x32,0x37,0x30,0x36,0x32,0x37,0x30,0x37,
-        0x32,0x37,0x30,0x38,0x32,0x37,0x30,0x39,
-        0x32,0x37,0x31,0x30,0x32,0x37,0x31,0x31,
-        0x32,0x37,0x31,0x32,0x32,0x37,0x31,0x33,
-        0x32,0x37,0x31,0x34,0x32,0x37,0x31,0x35,
-        0x32,0x37,0x31,0x36,0x32,0x37,0x31,0x37,
-        0x32,0x37,0x31,0x38,0x32,0x37,0x31,0x39,
-        0x32,0x37,0x32,0x30,0x32,0x37,0x32,0x31,
-        0x32,0x37,0x32,0x32,0x32,0x37,0x32,0x33,
-        0x32,0x37,0x32,0x34,0x32,0x37,0x32,0x35,
-        0x32,0x37,0x32,0x36,0x32,0x37,0x32,0x37,
-        0x32,0x37,0x32,0x38,0x32,0x37,0x32,0x39,
-        0x32,0x37,0x33,0x30,0x32,0x37,0x33,0x31,
-        0x32,0x37,0x33,0x32,0x32,0x37,0x33,0x33,
-        0x32,0x37,0x33,0x34,0x32,0x37,0x33,0x35,
-        0x32,0x37,0x33,0x36,0x32,0x37,0x33,0x37,
-        0x32,0x37,0x33,0x38,0x32,0x37,0x33,0x39,
-        0x32,0x37,0x34,0x30,0x32,0x37,0x34,0x31,
-        0x32,0x37,0x34,0x32,0x32,0x37,0x34,0x33,
-        0x32,0x37,0x34,0x34,0x32,0x37,0x34,0x35,
-        0x32,0x37,0x34,0x36,0x32,0x37,0x34,0x37,
-        0x32,0x37,0x34,0x38,0x32,0x37,0x34,0x39,
-        0x32,0x37,0x35,0x30,0x32,0x37,0x35,0x31,
-        0x32,0x37,0x35,0x32,0x32,0x37,0x35,0x33,
-        0x32,0x37,0x35,0x34,0x32,0x37,0x35,0x35,
-        0x32,0x37,0x35,0x36,0x32,0x37,0x35,0x37,
-        0x32,0x37,0x35,0x38,0x32,0x37,0x35,0x39,
-        0x32,0x37,0x36,0x30,0x32,0x37,0x36,0x31,
-        0x32,0x37,0x36,0x32,0x32,0x37,0x36,0x33,
-        0x32,0x37,0x36,0x34,0x32,0x37,0x36,0x35,
-        0x32,0x37,0x36,0x36,0x32,0x37,0x36,0x37,
-        0x32,0x37,0x36,0x38,0x32,0x37,0x36,0x39,
-        0x32,0x37,0x37,0x30,0x32,0x37,0x37,0x31,
-        0x32,0x37,0x37,0x32,0x32,0x37,0x37,0x33,
-        0x32,0x37,0x37,0x34,0x32,0x37,0x37,0x35,
-        0x32,0x37,0x37,0x36,0x32,0x37,0x37,0x37,
-        0x32,0x37,0x37,0x38,0x32,0x37,0x37,0x39,
-        0x32,0x37,0x38,0x30,0x32,0x37,0x38,0x31,
-        0x32,0x37,0x38,0x32,0x32,0x37,0x38,0x33,
-        0x32,0x37,0x38,0x34,0x32,0x37,0x38,0x35,
-        0x32,0x37,0x38,0x36,0x32,0x37,0x38,0x37,
-        0x32,0x37,0x38,0x38,0x32,0x37,0x38,0x39,
-        0x32,0x37,0x39,0x30,0x32,0x37,0x39,0x31,
-        0x32,0x37,0x39,0x32,0x32,0x37,0x39,0x33,
-        0x32,0x37,0x39,0x34,0x32,0x37,0x39,0x35,
-        0x32,0x37,0x39,0x36,0x32,0x37,0x39,0x37,
-        0x32,0x37,0x39,0x38,0x32,0x37,0x39,0x39,
-        0x32,0x38,0x30,0x30,0x32,0x38,0x30,0x31,
-        0x32,0x38,0x30,0x32,0x32,0x38,0x30,0x33,
-        0x32,0x38,0x30,0x34,0x32,0x38,0x30,0x35,
-        0x32,0x38,0x30,0x36,0x32,0x38,0x30,0x37,
-        0x32,0x38,0x30,0x38,0x32,0x38,0x30,0x39,
-        0x32,0x38,0x31,0x30,0x32,0x38,0x31,0x31,
-        0x32,0x38,0x31,0x32,0x32,0x38,0x31,0x33,
-        0x32,0x38,0x31,0x34,0x32,0x38,0x31,0x35,
-        0x32,0x38,0x31,0x36,0x32,0x38,0x31,0x37,
-        0x32,0x38,0x31,0x38,0x32,0x38,0x31,0x39,
-        0x32,0x38,0x32,0x30,0x32,0x38,0x32,0x31,
-        0x32,0x38,0x32,0x32,0x32,0x38,0x32,0x33,
-        0x32,0x38,0x32,0x34,0x32,0x38,0x32,0x35,
-        0x32,0x38,0x32,0x36,0x32,0x38,0x32,0x37,
-        0x32,0x38,0x32,0x38,0x32,0x38,0x32,0x39,
-        0x32,0x38,0x33,0x30,0x32,0x38,0x33,0x31,
-        0x32,0x38,0x33,0x32,0x32,0x38,0x33,0x33,
-        0x32,0x38,0x33,0x34,0x32,0x38,0x33,0x35,
-        0x32,0x38,0x33,0x36,0x32,0x38,0x33,0x37,
-        0x32,0x38,0x33,0x38,0x32,0x38,0x33,0x39,
-        0x32,0x38,0x34,0x30,0x32,0x38,0x34,0x31,
-        0x32,0x38,0x34,0x32,0x32,0x38,0x34,0x33,
-        0x32,0x38,0x34,0x34,0x32,0x38,0x34,0x35,
-        0x32,0x38,0x34,0x36,0x32,0x38,0x34,0x37,
-        0x32,0x38,0x34,0x38,0x32,0x38,0x34,0x39,
-        0x32,0x38,0x35,0x30,0x32,0x38,0x35,0x31,
-        0x32,0x38,0x35,0x32,0x32,0x38,0x35,0x33,
-        0x32,0x38,0x35,0x34,0x32,0x38,0x35,0x35,
-        0x32,0x38,0x35,0x36,0x32,0x38,0x35,0x37,
-        0x32,0x38,0x35,0x38,0x32,0x38,0x35,0x39,
-        0x32,0x38,0x36,0x30,0x32,0x38,0x36,0x31,
-        0x32,0x38,0x36,0x32,0x32,0x38,0x36,0x33,
-        0x32,0x38,0x36,0x34,0x32,0x38,0x36,0x35,
-        0x32,0x38,0x36,0x36,0x32,0x38,0x36,0x37,
-        0x32,0x38,0x36,0x38,0x32,0x38,0x36,0x39,
-        0x32,0x38,0x37,0x30,0x32,0x38,0x37,0x31,
-        0x32,0x38,0x37,0x32,0x32,0x38,0x37,0x33,
-        0x32,0x38,0x37,0x34,0x32,0x38,0x37,0x35,
-        0x32,0x38,0x37,0x36,0x32,0x38,0x37,0x37,
-        0x32,0x38,0x37,0x38,0x32,0x38,0x37,0x39,
-        0x32,0x38,0x38,0x30,0x32,0x38,0x38,0x31,
-        0x32,0x38,0x38,0x32,0x32,0x38,0x38,0x33,
-        0x32,0x38,0x38,0x34,0x32,0x38,0x38,0x35,
-        0x32,0x38,0x38,0x36,0x32,0x38,0x38,0x37,
-        0x32,0x38,0x38,0x38,0x32,0x38,0x38,0x39,
-        0x32,0x38,0x39,0x30,0x32,0x38,0x39,0x31,
-        0x32,0x38,0x39,0x32,0x32,0x38,0x39,0x33,
-        0x32,0x38,0x39,0x34,0x32,0x38,0x39,0x35,
-        0x32,0x38,0x39,0x36,0x32,0x38,0x39,0x37,
-        0x32,0x38,0x39,0x38,0x32,0x38,0x39,0x39,
-        0x32,0x39,0x30,0x30,0x32,0x39,0x30,0x31,
-        0x32,0x39,0x30,0x32,0x32,0x39,0x30,0x33,
-        0x32,0x39,0x30,0x34,0x32,0x39,0x30,0x35,
-        0x32,0x39,0x30,0x36,0x32,0x39,0x30,0x37,
-        0x32,0x39,0x30,0x38,0x32,0x39,0x30,0x39,
-        0x32,0x39,0x31,0x30,0x32,0x39,0x31,0x31,
-        0x32,0x39,0x31,0x32,0x32,0x39,0x31,0x33,
-        0x32,0x39,0x31,0x34,0x32,0x39,0x31,0x35,
-        0x32,0x39,0x31,0x36,0x32,0x39,0x31,0x37,
-        0x32,0x39,0x31,0x38,0x32,0x39,0x31,0x39,
-        0x32,0x39,0x32,0x30,0x32,0x39,0x32,0x31,
-        0x32,0x39,0x32,0x32,0x32,0x39,0x32,0x33,
-        0x32,0x39,0x32,0x34,0x32,0x39,0x32,0x35,
-        0x32,0x39,0x32,0x36,0x32,0x39,0x32,0x37,
-        0x32,0x39,0x32,0x38,0x32,0x39,0x32,0x39,
-        0x32,0x39,0x33,0x30,0x32,0x39,0x33,0x31,
-        0x32,0x39,0x33,0x32,0x32,0x39,0x33,0x33,
-        0x32,0x39,0x33,0x34,0x32,0x39,0x33,0x35,
-        0x32,0x39,0x33,0x36,0x32,0x39,0x33,0x37,
-        0x32,0x39,0x33,0x38,0x32,0x39,0x33,0x39,
-        0x32,0x39,0x34,0x30,0x32,0x39,0x34,0x31,
-        0x32,0x39,0x34,0x32,0x32,0x39,0x34,0x33,
-        0x32,0x39,0x34,0x34,0x32,0x39,0x34,0x35,
-        0x32,0x39,0x34,0x36,0x32,0x39,0x34,0x37,
-        0x32,0x39,0x34,0x38,0x32,0x39,0x34,0x39,
-        0x32,0x39,0x35,0x30,0x32,0x39,0x35,0x31,
-        0x32,0x39,0x35,0x32,0x32,0x39,0x35,0x33,
-        0x32,0x39,0x35,0x34,0x32,0x39,0x35,0x35,
-        0x32,0x39,0x35,0x36,0x32,0x39,0x35,0x37,
-        0x32,0x39,0x35,0x38,0x32,0x39,0x35,0x39,
-        0x32,0x39,0x36,0x30,0x32,0x39,0x36,0x31,
-        0x32,0x39,0x36,0x32,0x32,0x39,0x36,0x33,
-        0x32,0x39,0x36,0x34,0x32,0x39,0x36,0x35,
-        0x32,0x39,0x36,0x36,0x32,0x39,0x36,0x37,
-        0x32,0x39,0x36,0x38,0x32,0x39,0x36,0x39,
-        0x32,0x39,0x37,0x30,0x32,0x39,0x37,0x31,
-        0x32,0x39,0x37,0x32,0x32,0x39,0x37,0x33,
-        0x32,0x39,0x37,0x34,0x32,0x39,0x37,0x35,
-        0x32,0x39,0x37,0x36,0x32,0x39,0x37,0x37,
-        0x32,0x39,0x37,0x38,0x32,0x39,0x37,0x39,
-        0x32,0x39,0x38,0x30,0x32,0x39,0x38,0x31,
-        0x32,0x39,0x38,0x32,0x32,0x39,0x38,0x33,
-        0x32,0x39,0x38,0x34,0x32,0x39,0x38,0x35,
-        0x32,0x39,0x38,0x36,0x32,0x39,0x38,0x37,
-        0x32,0x39,0x38,0x38,0x32,0x39,0x38,0x39,
-        0x32,0x39,0x39,0x30,0x32,0x39,0x39,0x31,
-        0x32,0x39,0x39,0x32,0x32,0x39,0x39,0x33,
-        0x32,0x39,0x39,0x34,0x32,0x39,0x39,0x35,
-        0x32,0x39,0x39,0x36,0x32,0x39,0x39,0x37,
-        0x32,0x39,0x39,0x38,0x32,0x39,0x39,0x39,
-        0x33,0x30,0x30,0x30,0x33,0x30,0x30,0x31,
-        0x33,0x30,0x30,0x32,0x33,0x30,0x30,0x33,
-        0x33,0x30,0x30,0x34,0x33,0x30,0x30,0x35,
-        0x33,0x30,0x30,0x36,0x33,0x30,0x30,0x37,
-        0x33,0x30,0x30,0x38,0x33,0x30,0x30,0x39,
-        0x33,0x30,0x31,0x30,0x33,0x30,0x31,0x31,
-        0x33,0x30,0x31,0x32,0x33,0x30,0x31,0x33,
-        0x33,0x30,0x31,0x34,0x33,0x30,0x31,0x35,
-        0x33,0x30,0x31,0x36,0x33,0x30,0x31,0x37,
-        0x33,0x30,0x31,0x38,0x33,0x30,0x31,0x39,
-        0x33,0x30,0x32,0x30,0x33,0x30,0x32,0x31,
-        0x33,0x30,0x32,0x32,0x33,0x30,0x32,0x33,
-        0x33,0x30,0x32,0x34,0x33,0x30,0x32,0x35,
-        0x33,0x30,0x32,0x36,0x33,0x30,0x32,0x37,
-        0x33,0x30,0x32,0x38,0x33,0x30,0x32,0x39,
-        0x33,0x30,0x33,0x30,0x33,0x30,0x33,0x31,
-        0x33,0x30,0x33,0x32,0x33,0x30,0x33,0x33,
-        0x33,0x30,0x33,0x34,0x33,0x30,0x33,0x35,
-        0x33,0x30,0x33,0x36,0x33,0x30,0x33,0x37,
-        0x33,0x30,0x33,0x38,0x33,0x30,0x33,0x39,
-        0x33,0x30,0x34,0x30,0x33,0x30,0x34,0x31,
-        0x33,0x30,0x34,0x32,0x33,0x30,0x34,0x33,
-        0x33,0x30,0x34,0x34,0x33,0x30,0x34,0x35,
-        0x33,0x30,0x34,0x36,0x33,0x30,0x34,0x37,
-        0x33,0x30,0x34,0x38,0x33,0x30,0x34,0x39,
-        0x33,0x30,0x35,0x30,0x33,0x30,0x35,0x31,
-        0x33,0x30,0x35,0x32,0x33,0x30,0x35,0x33,
-        0x33,0x30,0x35,0x34,0x33,0x30,0x35,0x35,
-        0x33,0x30,0x35,0x36,0x33,0x30,0x35,0x37,
-        0x33,0x30,0x35,0x38,0x33,0x30,0x35,0x39,
-        0x33,0x30,0x36,0x30,0x33,0x30,0x36,0x31,
-        0x33,0x30,0x36,0x32,0x33,0x30,0x36,0x33,
-        0x33,0x30,0x36,0x34,0x33,0x30,0x36,0x35,
-        0x33,0x30,0x36,0x36,0x33,0x30,0x36,0x37,
-        0x33,0x30,0x36,0x38,0x33,0x30,0x36,0x39,
-        0x33,0x30,0x37,0x30,0x33,0x30,0x37,0x31,
-        0x33,0x30,0x37,0x32,0x33,0x30,0x37,0x33,
-        0x33,0x30,0x37,0x34,0x33,0x30,0x37,0x35,
-        0x33,0x30,0x37,0x36,0x33,0x30,0x37,0x37,
-        0x33,0x30,0x37,0x38,0x33,0x30,0x37,0x39,
-        0x33,0x30,0x38,0x30,0x33,0x30,0x38,0x31,
-        0x33,0x30,0x38,0x32,0x33,0x30,0x38,0x33,
-        0x33,0x30,0x38,0x34,0x33,0x30,0x38,0x35,
-        0x33,0x30,0x38,0x36,0x33,0x30,0x38,0x37,
-        0x33,0x30,0x38,0x38,0x33,0x30,0x38,0x39,
-        0x33,0x30,0x39,0x30,0x33,0x30,0x39,0x31,
-        0x33,0x30,0x39,0x32,0x33,0x30,0x39,0x33,
-        0x33,0x30,0x39,0x34,0x33,0x30,0x39,0x35,
-        0x33,0x30,0x39,0x36,0x33,0x30,0x39,0x37,
-        0x33,0x30,0x39,0x38,0x33,0x30,0x39,0x39,
-        0x33,0x31,0x30,0x30,0x33,0x31,0x30,0x31,
-        0x33,0x31,0x30,0x32,0x33,0x31,0x30,0x33,
-        0x33,0x31,0x30,0x34,0x33,0x31,0x30,0x35,
-        0x33,0x31,0x30,0x36,0x33,0x31,0x30,0x37,
-        0x33,0x31,0x30,0x38,0x33,0x31,0x30,0x39,
-        0x33,0x31,0x31,0x30,0x33,0x31,0x31,0x31,
-        0x33,0x31,0x31,0x32,0x33,0x31,0x31,0x33,
-        0x33,0x31,0x31,0x34,0x33,0x31,0x31,0x35,
-        0x33,0x31,0x31,0x36,0x33,0x31,0x31,0x37,
-        0x33,0x31,0x31,0x38,0x33,0x31,0x31,0x39,
-        0x33,0x31,0x32,0x30,0x33,0x31,0x32,0x31,
-        0x33,0x31,0x32,0x32,0x33,0x31,0x32,0x33,
-        0x33,0x31,0x32,0x34,0x33,0x31,0x32,0x35,
-        0x33,0x31,0x32,0x36,0x33,0x31,0x32,0x37,
-        0x33,0x31,0x32,0x38,0x33,0x31,0x32,0x39,
-        0x33,0x31,0x33,0x30,0x33,0x31,0x33,0x31,
-        0x33,0x31,0x33,0x32,0x33,0x31,0x33,0x33,
-        0x33,0x31,0x33,0x34,0x33,0x31,0x33,0x35,
-        0x33,0x31,0x33,0x36,0x33,0x31,0x33,0x37,
-        0x33,0x31,0x33,0x38,0x33,0x31,0x33,0x39,
-        0x33,0x31,0x34,0x30,0x33,0x31,0x34,0x31,
-        0x33,0x31,0x34,0x32,0x33,0x31,0x34,0x33,
-        0x33,0x31,0x34,0x34,0x33,0x31,0x34,0x35,
-        0x33,0x31,0x34,0x36,0x33,0x31,0x34,0x37,
-        0x33,0x31,0x34,0x38,0x33,0x31,0x34,0x39,
-        0x33,0x31,0x35,0x30,0x33,0x31,0x35,0x31,
-        0x33,0x31,0x35,0x32,0x33,0x31,0x35,0x33,
-        0x33,0x31,0x35,0x34,0x33,0x31,0x35,0x35,
-        0x33,0x31,0x35,0x36,0x33,0x31,0x35,0x37,
-        0x33,0x31,0x35,0x38,0x33,0x31,0x35,0x39,
-        0x33,0x31,0x36,0x30,0x33,0x31,0x36,0x31,
-        0x33,0x31,0x36,0x32,0x33,0x31,0x36,0x33,
-        0x33,0x31,0x36,0x34,0x33,0x31,0x36,0x35,
-        0x33,0x31,0x36,0x36,0x33,0x31,0x36,0x37,
-        0x33,0x31,0x36,0x38,0x33,0x31,0x36,0x39,
-        0x33,0x31,0x37,0x30,0x33,0x31,0x37,0x31,
-        0x33,0x31,0x37,0x32,0x33,0x31,0x37,0x33,
-        0x33,0x31,0x37,0x34,0x33,0x31,0x37,0x35,
-        0x33,0x31,0x37,0x36,0x33,0x31,0x37,0x37,
-        0x33,0x31,0x37,0x38,0x33,0x31,0x37,0x39,
-        0x33,0x31,0x38,0x30,0x33,0x31,0x38,0x31,
-        0x33,0x31,0x38,0x32,0x33,0x31,0x38,0x33,
-        0x33,0x31,0x38,0x34,0x33,0x31,0x38,0x35,
-        0x33,0x31,0x38,0x36,0x33,0x31,0x38,0x37,
-        0x33,0x31,0x38,0x38,0x33,0x31,0x38,0x39,
-        0x33,0x31,0x39,0x30,0x33,0x31,0x39,0x31,
-        0x33,0x31,0x39,0x32,0x33,0x31,0x39,0x33,
-        0x33,0x31,0x39,0x34,0x33,0x31,0x39,0x35,
-        0x33,0x31,0x39,0x36,0x33,0x31,0x39,0x37,
-        0x33,0x31,0x39,0x38,0x33,0x31,0x39,0x39,
-        0x33,0x32,0x30,0x30,0x33,0x32,0x30,0x31,
-        0x33,0x32,0x30,0x32,0x33,0x32,0x30,0x33,
-        0x33,0x32,0x30,0x34,0x33,0x32,0x30,0x35,
-        0x33,0x32,0x30,0x36,0x33,0x32,0x30,0x37,
-        0x33,0x32,0x30,0x38,0x33,0x32,0x30,0x39,
-        0x33,0x32,0x31,0x30,0x33,0x32,0x31,0x31,
-        0x33,0x32,0x31,0x32,0x33,0x32,0x31,0x33,
-        0x33,0x32,0x31,0x34,0x33,0x32,0x31,0x35,
-        0x33,0x32,0x31,0x36,0x33,0x32,0x31,0x37,
-        0x33,0x32,0x31,0x38,0x33,0x32,0x31,0x39,
-        0x33,0x32,0x32,0x30,0x33,0x32,0x32,0x31,
-        0x33,0x32,0x32,0x32,0x33,0x32,0x32,0x33,
-        0x33,0x32,0x32,0x34,0x33,0x32,0x32,0x35,
-        0x33,0x32,0x32,0x36,0x33,0x32,0x32,0x37,
-        0x33,0x32,0x32,0x38,0x33,0x32,0x32,0x39,
-        0x33,0x32,0x33,0x30,0x33,0x32,0x33,0x31,
-        0x33,0x32,0x33,0x32,0x33,0x32,0x33,0x33,
-        0x33,0x32,0x33,0x34,0x33,0x32,0x33,0x35,
-        0x33,0x32,0x33,0x36,0x33,0x32,0x33,0x37,
-        0x33,0x32,0x33,0x38,0x33,0x32,0x33,0x39,
-        0x33,0x32,0x34,0x30,0x33,0x32,0x34,0x31,
-        0x33,0x32,0x34,0x32,0x33,0x32,0x34,0x33,
-        0x33,0x32,0x34,0x34,0x33,0x32,0x34,0x35,
-        0x33,0x32,0x34,0x36,0x33,0x32,0x34,0x37,
-        0x33,0x32,0x34,0x38,0x33,0x32,0x34,0x39,
-        0x33,0x32,0x35,0x30,0x33,0x32,0x35,0x31,
-        0x33,0x32,0x35,0x32,0x33,0x32,0x35,0x33,
-        0x33,0x32,0x35,0x34,0x33,0x32,0x35,0x35,
-        0x33,0x32,0x35,0x36,0x33,0x32,0x35,0x37,
-        0x33,0x32,0x35,0x38,0x33,0x32,0x35,0x39,
-        0x33,0x32,0x36,0x30,0x33,0x32,0x36,0x31,
-        0x33,0x32,0x36,0x32,0x33,0x32,0x36,0x33,
-        0x33,0x32,0x36,0x34,0x33,0x32,0x36,0x35,
-        0x33,0x32,0x36,0x36,0x33,0x32,0x36,0x37,
-        0x33,0x32,0x36,0x38,0x33,0x32,0x36,0x39,
-        0x33,0x32,0x37,0x30,0x33,0x32,0x37,0x31,
-        0x33,0x32,0x37,0x32,0x33,0x32,0x37,0x33,
-        0x33,0x32,0x37,0x34,0x33,0x32,0x37,0x35,
-        0x33,0x32,0x37,0x36,0x33,0x32,0x37,0x37,
-        0x33,0x32,0x37,0x38,0x33,0x32,0x37,0x39,
-        0x33,0x32,0x38,0x30,0x33,0x32,0x38,0x31,
-        0x33,0x32,0x38,0x32,0x33,0x32,0x38,0x33,
-        0x33,0x32,0x38,0x34,0x33,0x32,0x38,0x35,
-        0x33,0x32,0x38,0x36,0x33,0x32,0x38,0x37,
-        0x33,0x32,0x38,0x38,0x33,0x32,0x38,0x39,
-        0x33,0x32,0x39,0x30,0x33,0x32,0x39,0x31,
-        0x33,0x32,0x39,0x32,0x33,0x32,0x39,0x33,
-        0x33,0x32,0x39,0x34,0x33,0x32,0x39,0x35,
-        0x33,0x32,0x39,0x36,0x33,0x32,0x39,0x37,
-        0x33,0x32,0x39,0x38,0x33,0x32,0x39,0x39,
-        0x33,0x33,0x30,0x30,0x33,0x33,0x30,0x31,
-        0x33,0x33,0x30,0x32,0x33,0x33,0x30,0x33,
-        0x33,0x33,0x30,0x34,0x33,0x33,0x30,0x35,
-        0x33,0x33,0x30,0x36,0x33,0x33,0x30,0x37,
-        0x33,0x33,0x30,0x38,0x33,0x33,0x30,0x39,
-        0x33,0x33,0x31,0x30,0x33,0x33,0x31,0x31,
-        0x33,0x33,0x31,0x32,0x33,0x33,0x31,0x33,
-        0x33,0x33,0x31,0x34,0x33,0x33,0x31,0x35,
-        0x33,0x33,0x31,0x36,0x33,0x33,0x31,0x37,
-        0x33,0x33,0x31,0x38,0x33,0x33,0x31,0x39,
-        0x33,0x33,0x32,0x30,0x33,0x33,0x32,0x31,
-        0x33,0x33,0x32,0x32,0x33,0x33,0x32,0x33,
-        0x33,0x33,0x32,0x34,0x33,0x33,0x32,0x35,
-        0x33,0x33,0x32,0x36,0x33,0x33,0x32,0x37,
-        0x33,0x33,0x32,0x38,0x33,0x33,0x32,0x39,
-        0x33,0x33,0x33,0x30,0x33,0x33,0x33,0x31,
-        0x33,0x33,0x33,0x32,0x33,0x33,0x33,0x33,
-        0x33,0x33,0x33,0x34,0x33,0x33,0x33,0x35,
-        0x33,0x33,0x33,0x36,0x33,0x33,0x33,0x37,
-        0x33,0x33,0x33,0x38,0x33,0x33,0x33,0x39,
-        0x33,0x33,0x34,0x30,0x33,0x33,0x34,0x31,
-        0x33,0x33,0x34,0x32,0x33,0x33,0x34,0x33,
-        0x33,0x33,0x34,0x34,0x33,0x33,0x34,0x35,
-        0x33,0x33,0x34,0x36,0x33,0x33,0x34,0x37,
-        0x33,0x33,0x34,0x38,0x33,0x33,0x34,0x39,
-        0x33,0x33,0x35,0x30,0x33,0x33,0x35,0x31,
-        0x33,0x33,0x35,0x32,0x33,0x33,0x35,0x33,
-        0x33,0x33,0x35,0x34,0x33,0x33,0x35,0x35,
-        0x33,0x33,0x35,0x36,0x33,0x33,0x35,0x37,
-        0x33,0x33,0x35,0x38,0x33,0x33,0x35,0x39,
-        0x33,0x33,0x36,0x30,0x33,0x33,0x36,0x31,
-        0x33,0x33,0x36,0x32,0x33,0x33,0x36,0x33,
-        0x33,0x33,0x36,0x34,0x33,0x33,0x36,0x35,
-        0x33,0x33,0x36,0x36,0x33,0x33,0x36,0x37,
-        0x33,0x33,0x36,0x38,0x33,0x33,0x36,0x39,
-        0x33,0x33,0x37,0x30,0x33,0x33,0x37,0x31,
-        0x33,0x33,0x37,0x32,0x33,0x33,0x37,0x33,
-        0x33,0x33,0x37,0x34,0x33,0x33,0x37,0x35,
-        0x33,0x33,0x37,0x36,0x33,0x33,0x37,0x37,
-        0x33,0x33,0x37,0x38,0x33,0x33,0x37,0x39,
-        0x33,0x33,0x38,0x30,0x33,0x33,0x38,0x31,
-        0x33,0x33,0x38,0x32,0x33,0x33,0x38,0x33,
-        0x33,0x33,0x38,0x34,0x33,0x33,0x38,0x35,
-        0x33,0x33,0x38,0x36,0x33,0x33,0x38,0x37,
-        0x33,0x33,0x38,0x38,0x33,0x33,0x38,0x39,
-        0x33,0x33,0x39,0x30,0x33,0x33,0x39,0x31,
-        0x33,0x33,0x39,0x32,0x33,0x33,0x39,0x33,
-        0x33,0x33,0x39,0x34,0x33,0x33,0x39,0x35,
-        0x33,0x33,0x39,0x36,0x33,0x33,0x39,0x37,
-        0x33,0x33,0x39,0x38,0x33,0x33,0x39,0x39,
-        0x33,0x34,0x30,0x30,0x33,0x34,0x30,0x31,
-        0x33,0x34,0x30,0x32,0x33,0x34,0x30,0x33,
-        0x33,0x34,0x30,0x34,0x33,0x34,0x30,0x35,
-        0x33,0x34,0x30,0x36,0x33,0x34,0x30,0x37,
-        0x33,0x34,0x30,0x38,0x33,0x34,0x30,0x39,
-        0x33,0x34,0x31,0x30,0x33,0x34,0x31,0x31,
-        0x33,0x34,0x31,0x32,0x33,0x34,0x31,0x33,
-        0x33,0x34,0x31,0x34,0x33,0x34,0x31,0x35,
-        0x33,0x34,0x31,0x36,0x33,0x34,0x31,0x37,
-        0x33,0x34,0x31,0x38,0x33,0x34,0x31,0x39,
-        0x33,0x34,0x32,0x30,0x33,0x34,0x32,0x31,
-        0x33,0x34,0x32,0x32,0x33,0x34,0x32,0x33,
-        0x33,0x34,0x32,0x34,0x33,0x34,0x32,0x35,
-        0x33,0x34,0x32,0x36,0x33,0x34,0x32,0x37,
-        0x33,0x34,0x32,0x38,0x33,0x34,0x32,0x39,
-        0x33,0x34,0x33,0x30,0x33,0x34,0x33,0x31,
-        0x33,0x34,0x33,0x32,0x33,0x34,0x33,0x33,
-        0x33,0x34,0x33,0x34,0x33,0x34,0x33,0x35,
-        0x33,0x34,0x33,0x36,0x33,0x34,0x33,0x37,
-        0x33,0x34,0x33,0x38,0x33,0x34,0x33,0x39,
-        0x33,0x34,0x34,0x30,0x33,0x34,0x34,0x31,
-        0x33,0x34,0x34,0x32,0x33,0x34,0x34,0x33,
-        0x33,0x34,0x34,0x34,0x33,0x34,0x34,0x35,
-        0x33,0x34,0x34,0x36,0x33,0x34,0x34,0x37,
-        0x33,0x34,0x34,0x38,0x33,0x34,0x34,0x39,
-        0x33,0x34,0x35,0x30,0x33,0x34,0x35,0x31,
-        0x33,0x34,0x35,0x32,0x33,0x34,0x35,0x33,
-        0x33,0x34,0x35,0x34,0x33,0x34,0x35,0x35,
-        0x33,0x34,0x35,0x36,0x33,0x34,0x35,0x37,
-        0x33,0x34,0x35,0x38,0x33,0x34,0x35,0x39,
-        0x33,0x34,0x36,0x30,0x33,0x34,0x36,0x31,
-        0x33,0x34,0x36,0x32,0x33,0x34,0x36,0x33,
-        0x33,0x34,0x36,0x34,0x33,0x34,0x36,0x35,
-        0x33,0x34,0x36,0x36,0x33,0x34,0x36,0x37,
-        0x33,0x34,0x36,0x38,0x33,0x34,0x36,0x39,
-        0x33,0x34,0x37,0x30,0x33,0x34,0x37,0x31,
-        0x33,0x34,0x37,0x32,0x33,0x34,0x37,0x33,
-        0x33,0x34,0x37,0x34,0x33,0x34,0x37,0x35,
-        0x33,0x34,0x37,0x36,0x33,0x34,0x37,0x37,
-        0x33,0x34,0x37,0x38,0x33,0x34,0x37,0x39,
-        0x33,0x34,0x38,0x30,0x33,0x34,0x38,0x31,
-        0x33,0x34,0x38,0x32,0x33,0x34,0x38,0x33,
-        0x33,0x34,0x38,0x34,0x33,0x34,0x38,0x35,
-        0x33,0x34,0x38,0x36,0x33,0x34,0x38,0x37,
-        0x33,0x34,0x38,0x38,0x33,0x34,0x38,0x39,
-        0x33,0x34,0x39,0x30,0x33,0x34,0x39,0x31,
-        0x33,0x34,0x39,0x32,0x33,0x34,0x39,0x33,
-        0x33,0x34,0x39,0x34,0x33,0x34,0x39,0x35,
-        0x33,0x34,0x39,0x36,0x33,0x34,0x39,0x37,
-        0x33,0x34,0x39,0x38,0x33,0x34,0x39,0x39,
-        0x33,0x35,0x30,0x30,0x33,0x35,0x30,0x31,
-        0x33,0x35,0x30,0x32,0x33,0x35,0x30,0x33,
-        0x33,0x35,0x30,0x34,0x33,0x35,0x30,0x35,
-        0x33,0x35,0x30,0x36,0x33,0x35,0x30,0x37,
-        0x33,0x35,0x30,0x38,0x33,0x35,0x30,0x39,
-        0x33,0x35,0x31,0x30,0x33,0x35,0x31,0x31,
-        0x33,0x35,0x31,0x32,0x33,0x35,0x31,0x33,
-        0x33,0x35,0x31,0x34,0x33,0x35,0x31,0x35,
-        0x33,0x35,0x31,0x36,0x33,0x35,0x31,0x37,
-        0x33,0x35,0x31,0x38,0x33,0x35,0x31,0x39,
-        0x33,0x35,0x32,0x30,0x33,0x35,0x32,0x31,
-        0x33,0x35,0x32,0x32,0x33,0x35,0x32,0x33,
-        0x33,0x35,0x32,0x34,0x33,0x35,0x32,0x35,
-        0x33,0x35,0x32,0x36,0x33,0x35,0x32,0x37,
-        0x33,0x35,0x32,0x38,0x33,0x35,0x32,0x39,
-        0x33,0x35,0x33,0x30,0x33,0x35,0x33,0x31,
-        0x33,0x35,0x33,0x32,0x33,0x35,0x33,0x33,
-        0x33,0x35,0x33,0x34,0x33,0x35,0x33,0x35,
-        0x33,0x35,0x33,0x36,0x33,0x35,0x33,0x37,
-        0x33,0x35,0x33,0x38,0x33,0x35,0x33,0x39,
-        0x33,0x35,0x34,0x30,0x33,0x35,0x34,0x31,
-        0x33,0x35,0x34,0x32,0x33,0x35,0x34,0x33,
-        0x33,0x35,0x34,0x34,0x33,0x35,0x34,0x35,
-        0x33,0x35,0x34,0x36,0x33,0x35,0x34,0x37,
-        0x33,0x35,0x34,0x38,0x33,0x35,0x34,0x39,
-        0x33,0x35,0x35,0x30,0x33,0x35,0x35,0x31,
-        0x33,0x35,0x35,0x32,0x33,0x35,0x35,0x33,
-        0x33,0x35,0x35,0x34,0x33,0x35,0x35,0x35,
-        0x33,0x35,0x35,0x36,0x33,0x35,0x35,0x37,
-        0x33,0x35,0x35,0x38,0x33,0x35,0x35,0x39,
-        0x33,0x35,0x36,0x30,0x33,0x35,0x36,0x31,
-        0x33,0x35,0x36,0x32,0x33,0x35,0x36,0x33,
-        0x33,0x35,0x36,0x34,0x33,0x35,0x36,0x35,
-        0x33,0x35,0x36,0x36,0x33,0x35,0x36,0x37,
-        0x33,0x35,0x36,0x38,0x33,0x35,0x36,0x39,
-        0x33,0x35,0x37,0x30,0x33,0x35,0x37,0x31,
-        0x33,0x35,0x37,0x32,0x33,0x35,0x37,0x33,
-        0x33,0x35,0x37,0x34,0x33,0x35,0x37,0x35,
-        0x33,0x35,0x37,0x36,0x33,0x35,0x37,0x37,
-        0x33,0x35,0x37,0x38,0x33,0x35,0x37,0x39,
-        0x33,0x35,0x38,0x30,0x33,0x35,0x38,0x31,
-        0x33,0x35,0x38,0x32,0x33,0x35,0x38,0x33,
-        0x33,0x35,0x38,0x34,0x33,0x35,0x38,0x35,
-        0x33,0x35,0x38,0x36,0x33,0x35,0x38,0x37,
-        0x33,0x35,0x38,0x38,0x33,0x35,0x38,0x39,
-        0x33,0x35,0x39,0x30,0x33,0x35,0x39,0x31,
-        0x33,0x35,0x39,0x32,0x33,0x35,0x39,0x33,
-        0x33,0x35,0x39,0x34,0x33,0x35,0x39,0x35,
-        0x33,0x35,0x39,0x36,0x33,0x35,0x39,0x37,
-        0x33,0x35,0x39,0x38,0x33,0x35,0x39,0x39,
-        0x33,0x36,0x30,0x30,0x33,0x36,0x30,0x31,
-        0x33,0x36,0x30,0x32,0x33,0x36,0x30,0x33,
-        0x33,0x36,0x30,0x34,0x33,0x36,0x30,0x35,
-        0x33,0x36,0x30,0x36,0x33,0x36,0x30,0x37,
-        0x33,0x36,0x30,0x38,0x33,0x36,0x30,0x39,
-        0x33,0x36,0x31,0x30,0x33,0x36,0x31,0x31,
-        0x33,0x36,0x31,0x32,0x33,0x36,0x31,0x33,
-        0x33,0x36,0x31,0x34,0x33,0x36,0x31,0x35,
-        0x33,0x36,0x31,0x36,0x33,0x36,0x31,0x37,
-        0x33,0x36,0x31,0x38,0x33,0x36,0x31,0x39,
-        0x33,0x36,0x32,0x30,0x33,0x36,0x32,0x31,
-        0x33,0x36,0x32,0x32,0x33,0x36,0x32,0x33,
-        0x33,0x36,0x32,0x34,0x33,0x36,0x32,0x35,
-        0x33,0x36,0x32,0x36,0x33,0x36,0x32,0x37,
-        0x33,0x36,0x32,0x38,0x33,0x36,0x32,0x39,
-        0x33,0x36,0x33,0x30,0x33,0x36,0x33,0x31,
-        0x33,0x36,0x33,0x32,0x33,0x36,0x33,0x33,
-        0x33,0x36,0x33,0x34,0x33,0x36,0x33,0x35,
-        0x33,0x36,0x33,0x36,0x33,0x36,0x33,0x37,
-        0x33,0x36,0x33,0x38,0x33,0x36,0x33,0x39,
-        0x33,0x36,0x34,0x30,0x33,0x36,0x34,0x31,
-        0x33,0x36,0x34,0x32,0x33,0x36,0x34,0x33,
-        0x33,0x36,0x34,0x34,0x33,0x36,0x34,0x35,
-        0x33,0x36,0x34,0x36,0x33,0x36,0x34,0x37,
-        0x33,0x36,0x34,0x38,0x33,0x36,0x34,0x39,
-        0x33,0x36,0x35,0x30,0x33,0x36,0x35,0x31,
-        0x33,0x36,0x35,0x32,0x33,0x36,0x35,0x33,
-        0x33,0x36,0x35,0x34,0x33,0x36,0x35,0x35,
-        0x33,0x36,0x35,0x36,0x33,0x36,0x35,0x37,
-        0x33,0x36,0x35,0x38,0x33,0x36,0x35,0x39,
-        0x33,0x36,0x36,0x30,0x33,0x36,0x36,0x31,
-        0x33,0x36,0x36,0x32,0x33,0x36,0x36,0x33,
-        0x33,0x36,0x36,0x34,0x33,0x36,0x36,0x35,
-        0x33,0x36,0x36,0x36,0x33,0x36,0x36,0x37,
-        0x33,0x36,0x36,0x38,0x33,0x36,0x36,0x39,
-        0x33,0x36,0x37,0x30,0x33,0x36,0x37,0x31,
-        0x33,0x36,0x37,0x32,0x33,0x36,0x37,0x33,
-        0x33,0x36,0x37,0x34,0x33,0x36,0x37,0x35,
-        0x33,0x36,0x37,0x36,0x33,0x36,0x37,0x37,
-        0x33,0x36,0x37,0x38,0x33,0x36,0x37,0x39,
-        0x33,0x36,0x38,0x30,0x33,0x36,0x38,0x31,
-        0x33,0x36,0x38,0x32,0x33,0x36,0x38,0x33,
-        0x33,0x36,0x38,0x34,0x33,0x36,0x38,0x35,
-        0x33,0x36,0x38,0x36,0x33,0x36,0x38,0x37,
-        0x33,0x36,0x38,0x38,0x33,0x36,0x38,0x39,
-        0x33,0x36,0x39,0x30,0x33,0x36,0x39,0x31,
-        0x33,0x36,0x39,0x32,0x33,0x36,0x39,0x33,
-        0x33,0x36,0x39,0x34,0x33,0x36,0x39,0x35,
-        0x33,0x36,0x39,0x36,0x33,0x36,0x39,0x37,
-        0x33,0x36,0x39,0x38,0x33,0x36,0x39,0x39,
-        0x33,0x37,0x30,0x30,0x33,0x37,0x30,0x31,
-        0x33,0x37,0x30,0x32,0x33,0x37,0x30,0x33,
-        0x33,0x37,0x30,0x34,0x33,0x37,0x30,0x35,
-        0x33,0x37,0x30,0x36,0x33,0x37,0x30,0x37,
-        0x33,0x37,0x30,0x38,0x33,0x37,0x30,0x39,
-        0x33,0x37,0x31,0x30,0x33,0x37,0x31,0x31,
-        0x33,0x37,0x31,0x32,0x33,0x37,0x31,0x33,
-        0x33,0x37,0x31,0x34,0x33,0x37,0x31,0x35,
-        0x33,0x37,0x31,0x36,0x33,0x37,0x31,0x37,
-        0x33,0x37,0x31,0x38,0x33,0x37,0x31,0x39,
-        0x33,0x37,0x32,0x30,0x33,0x37,0x32,0x31,
-        0x33,0x37,0x32,0x32,0x33,0x37,0x32,0x33,
-        0x33,0x37,0x32,0x34,0x33,0x37,0x32,0x35,
-        0x33,0x37,0x32,0x36,0x33,0x37,0x32,0x37,
-        0x33,0x37,0x32,0x38,0x33,0x37,0x32,0x39,
-        0x33,0x37,0x33,0x30,0x33,0x37,0x33,0x31,
-        0x33,0x37,0x33,0x32,0x33,0x37,0x33,0x33,
-        0x33,0x37,0x33,0x34,0x33,0x37,0x33,0x35,
-        0x33,0x37,0x33,0x36,0x33,0x37,0x33,0x37,
-        0x33,0x37,0x33,0x38,0x33,0x37,0x33,0x39,
-        0x33,0x37,0x34,0x30,0x33,0x37,0x34,0x31,
-        0x33,0x37,0x34,0x32,0x33,0x37,0x34,0x33,
-        0x33,0x37,0x34,0x34,0x33,0x37,0x34,0x35,
-        0x33,0x37,0x34,0x36,0x33,0x37,0x34,0x37,
-        0x33,0x37,0x34,0x38,0x33,0x37,0x34,0x39,
-        0x33,0x37,0x35,0x30,0x33,0x37,0x35,0x31,
-        0x33,0x37,0x35,0x32,0x33,0x37,0x35,0x33,
-        0x33,0x37,0x35,0x34,0x33,0x37,0x35,0x35,
-        0x33,0x37,0x35,0x36,0x33,0x37,0x35,0x37,
-        0x33,0x37,0x35,0x38,0x33,0x37,0x35,0x39,
-        0x33,0x37,0x36,0x30,0x33,0x37,0x36,0x31,
-        0x33,0x37,0x36,0x32,0x33,0x37,0x36,0x33,
-        0x33,0x37,0x36,0x34,0x33,0x37,0x36,0x35,
-        0x33,0x37,0x36,0x36,0x33,0x37,0x36,0x37,
-        0x33,0x37,0x36,0x38,0x33,0x37,0x36,0x39,
-        0x33,0x37,0x37,0x30,0x33,0x37,0x37,0x31,
-        0x33,0x37,0x37,0x32,0x33,0x37,0x37,0x33,
-        0x33,0x37,0x37,0x34,0x33,0x37,0x37,0x35,
-        0x33,0x37,0x37,0x36,0x33,0x37,0x37,0x37,
-        0x33,0x37,0x37,0x38,0x33,0x37,0x37,0x39,
-        0x33,0x37,0x38,0x30,0x33,0x37,0x38,0x31,
-        0x33,0x37,0x38,0x32,0x33,0x37,0x38,0x33,
-        0x33,0x37,0x38,0x34,0x33,0x37,0x38,0x35,
-        0x33,0x37,0x38,0x36,0x33,0x37,0x38,0x37,
-        0x33,0x37,0x38,0x38,0x33,0x37,0x38,0x39,
-        0x33,0x37,0x39,0x30,0x33,0x37,0x39,0x31,
-        0x33,0x37,0x39,0x32,0x33,0x37,0x39,0x33,
-        0x33,0x37,0x39,0x34,0x33,0x37,0x39,0x35,
-        0x33,0x37,0x39,0x36,0x33,0x37,0x39,0x37,
-        0x33,0x37,0x39,0x38,0x33,0x37,0x39,0x39,
-        0x33,0x38,0x30,0x30,0x33,0x38,0x30,0x31,
-        0x33,0x38,0x30,0x32,0x33,0x38,0x30,0x33,
-        0x33,0x38,0x30,0x34,0x33,0x38,0x30,0x35,
-        0x33,0x38,0x30,0x36,0x33,0x38,0x30,0x37,
-        0x33,0x38,0x30,0x38,0x33,0x38,0x30,0x39,
-        0x33,0x38,0x31,0x30,0x33,0x38,0x31,0x31,
-        0x33,0x38,0x31,0x32,0x33,0x38,0x31,0x33,
-        0x33,0x38,0x31,0x34,0x33,0x38,0x31,0x35,
-        0x33,0x38,0x31,0x36,0x33,0x38,0x31,0x37,
-        0x33,0x38,0x31,0x38,0x33,0x38,0x31,0x39,
-        0x33,0x38,0x32,0x30,0x33,0x38,0x32,0x31,
-        0x33,0x38,0x32,0x32,0x33,0x38,0x32,0x33,
-        0x33,0x38,0x32,0x34,0x33,0x38,0x32,0x35,
-        0x33,0x38,0x32,0x36,0x33,0x38,0x32,0x37,
-        0x33,0x38,0x32,0x38,0x33,0x38,0x32,0x39,
-        0x33,0x38,0x33,0x30,0x33,0x38,0x33,0x31,
-        0x33,0x38,0x33,0x32,0x33,0x38,0x33,0x33,
-        0x33,0x38,0x33,0x34,0x33,0x38,0x33,0x35,
-        0x33,0x38,0x33,0x36,0x33,0x38,0x33,0x37,
-        0x33,0x38,0x33,0x38,0x33,0x38,0x33,0x39,
-        0x33,0x38,0x34,0x30,0x33,0x38,0x34,0x31,
-        0x33,0x38,0x34,0x32,0x33,0x38,0x34,0x33,
-        0x33,0x38,0x34,0x34,0x33,0x38,0x34,0x35,
-        0x33,0x38,0x34,0x36,0x33,0x38,0x34,0x37,
-        0x33,0x38,0x34,0x38,0x33,0x38,0x34,0x39,
-        0x33,0x38,0x35,0x30,0x33,0x38,0x35,0x31,
-        0x33,0x38,0x35,0x32,0x33,0x38,0x35,0x33,
-        0x33,0x38,0x35,0x34,0x33,0x38,0x35,0x35,
-        0x33,0x38,0x35,0x36,0x33,0x38,0x35,0x37,
-        0x33,0x38,0x35,0x38,0x33,0x38,0x35,0x39,
-        0x33,0x38,0x36,0x30,0x33,0x38,0x36,0x31,
-        0x33,0x38,0x36,0x32,0x33,0x38,0x36,0x33,
-        0x33,0x38,0x36,0x34,0x33,0x38,0x36,0x35,
-        0x33,0x38,0x36,0x36,0x33,0x38,0x36,0x37,
-        0x33,0x38,0x36,0x38,0x33,0x38,0x36,0x39,
-        0x33,0x38,0x37,0x30,0x33,0x38,0x37,0x31,
-        0x33,0x38,0x37,0x32,0x33,0x38,0x37,0x33,
-        0x33,0x38,0x37,0x34,0x33,0x38,0x37,0x35,
-        0x33,0x38,0x37,0x36,0x33,0x38,0x37,0x37,
-        0x33,0x38,0x37,0x38,0x33,0x38,0x37,0x39,
-        0x33,0x38,0x38,0x30,0x33,0x38,0x38,0x31,
-        0x33,0x38,0x38,0x32,0x33,0x38,0x38,0x33,
-        0x33,0x38,0x38,0x34,0x33,0x38,0x38,0x35,
-        0x33,0x38,0x38,0x36,0x33,0x38,0x38,0x37,
-        0x33,0x38,0x38,0x38,0x33,0x38,0x38,0x39,
-        0x33,0x38,0x39,0x30,0x33,0x38,0x39,0x31,
-        0x33,0x38,0x39,0x32,0x33,0x38,0x39,0x33,
-        0x33,0x38,0x39,0x34,0x33,0x38,0x39,0x35,
-        0x33,0x38,0x39,0x36,0x33,0x38,0x39,0x37,
-        0x33,0x38,0x39,0x38,0x33,0x38,0x39,0x39,
-        0x33,0x39,0x30,0x30,0x33,0x39,0x30,0x31,
-        0x33,0x39,0x30,0x32,0x33,0x39,0x30,0x33,
-        0x33,0x39,0x30,0x34,0x33,0x39,0x30,0x35,
-        0x33,0x39,0x30,0x36,0x33,0x39,0x30,0x37,
-        0x33,0x39,0x30,0x38,0x33,0x39,0x30,0x39,
-        0x33,0x39,0x31,0x30,0x33,0x39,0x31,0x31,
-        0x33,0x39,0x31,0x32,0x33,0x39,0x31,0x33,
-        0x33,0x39,0x31,0x34,0x33,0x39,0x31,0x35,
-        0x33,0x39,0x31,0x36,0x33,0x39,0x31,0x37,
-        0x33,0x39,0x31,0x38,0x33,0x39,0x31,0x39,
-        0x33,0x39,0x32,0x30,0x33,0x39,0x32,0x31,
-        0x33,0x39,0x32,0x32,0x33,0x39,0x32,0x33,
-        0x33,0x39,0x32,0x34,0x33,0x39,0x32,0x35,
-        0x33,0x39,0x32,0x36,0x33,0x39,0x32,0x37,
-        0x33,0x39,0x32,0x38,0x33,0x39,0x32,0x39,
-        0x33,0x39,0x33,0x30,0x33,0x39,0x33,0x31,
-        0x33,0x39,0x33,0x32,0x33,0x39,0x33,0x33,
-        0x33,0x39,0x33,0x34,0x33,0x39,0x33,0x35,
-        0x33,0x39,0x33,0x36,0x33,0x39,0x33,0x37,
-        0x33,0x39,0x33,0x38,0x33,0x39,0x33,0x39,
-        0x33,0x39,0x34,0x30,0x33,0x39,0x34,0x31,
-        0x33,0x39,0x34,0x32,0x33,0x39,0x34,0x33,
-        0x33,0x39,0x34,0x34,0x33,0x39,0x34,0x35,
-        0x33,0x39,0x34,0x36,0x33,0x39,0x34,0x37,
-        0x33,0x39,0x34,0x38,0x33,0x39,0x34,0x39,
-        0x33,0x39,0x35,0x30,0x33,0x39,0x35,0x31,
-        0x33,0x39,0x35,0x32,0x33,0x39,0x35,0x33,
-        0x33,0x39,0x35,0x34,0x33,0x39,0x35,0x35,
-        0x33,0x39,0x35,0x36,0x33,0x39,0x35,0x37,
-        0x33,0x39,0x35,0x38,0x33,0x39,0x35,0x39,
-        0x33,0x39,0x36,0x30,0x33,0x39,0x36,0x31,
-        0x33,0x39,0x36,0x32,0x33,0x39,0x36,0x33,
-        0x33,0x39,0x36,0x34,0x33,0x39,0x36,0x35,
-        0x33,0x39,0x36,0x36,0x33,0x39,0x36,0x37,
-        0x33,0x39,0x36,0x38,0x33,0x39,0x36,0x39,
-        0x33,0x39,0x37,0x30,0x33,0x39,0x37,0x31,
-        0x33,0x39,0x37,0x32,0x33,0x39,0x37,0x33,
-        0x33,0x39,0x37,0x34,0x33,0x39,0x37,0x35,
-        0x33,0x39,0x37,0x36,0x33,0x39,0x37,0x37,
-        0x33,0x39,0x37,0x38,0x33,0x39,0x37,0x39,
-        0x33,0x39,0x38,0x30,0x33,0x39,0x38,0x31,
-        0x33,0x39,0x38,0x32,0x33,0x39,0x38,0x33,
-        0x33,0x39,0x38,0x34,0x33,0x39,0x38,0x35,
-        0x33,0x39,0x38,0x36,0x33,0x39,0x38,0x37,
-        0x33,0x39,0x38,0x38,0x33,0x39,0x38,0x39,
-        0x33,0x39,0x39,0x30,0x33,0x39,0x39,0x31,
-        0x33,0x39,0x39,0x32,0x33,0x39,0x39,0x33,
-        0x33,0x39,0x39,0x34,0x33,0x39,0x39,0x35,
-        0x33,0x39,0x39,0x36,0x33,0x39,0x39,0x37,
-        0x33,0x39,0x39,0x38,0x33,0x39,0x39,0x39,
-        0x34,0x30,0x30,0x30,0x34,0x30,0x30,0x31,
-        0x34,0x30,0x30,0x32,0x34,0x30,0x30,0x33,
-        0x34,0x30,0x30,0x34,0x34,0x30,0x30,0x35,
-        0x34,0x30,0x30,0x36,0x34,0x30,0x30,0x37,
-        0x34,0x30,0x30,0x38,0x34,0x30,0x30,0x39,
-        0x34,0x30,0x31,0x30,0x34,0x30,0x31,0x31,
-        0x34,0x30,0x31,0x32,0x34,0x30,0x31,0x33,
-        0x34,0x30,0x31,0x34,0x34,0x30,0x31,0x35,
-        0x34,0x30,0x31,0x36,0x34,0x30,0x31,0x37,
-        0x34,0x30,0x31,0x38,0x34,0x30,0x31,0x39,
-        0x34,0x30,0x32,0x30,0x34,0x30,0x32,0x31,
-        0x34,0x30,0x32,0x32,0x34,0x30,0x32,0x33,
-        0x34,0x30,0x32,0x34,0x34,0x30,0x32,0x35,
-        0x34,0x30,0x32,0x36,0x34,0x30,0x32,0x37,
-        0x34,0x30,0x32,0x38,0x34,0x30,0x32,0x39,
-        0x34,0x30,0x33,0x30,0x34,0x30,0x33,0x31,
-        0x34,0x30,0x33,0x32,0x34,0x30,0x33,0x33,
-        0x34,0x30,0x33,0x34,0x34,0x30,0x33,0x35,
-        0x34,0x30,0x33,0x36,0x34,0x30,0x33,0x37,
-        0x34,0x30,0x33,0x38,0x34,0x30,0x33,0x39,
-        0x34,0x30,0x34,0x30,0x34,0x30,0x34,0x31,
-        0x34,0x30,0x34,0x32,0x34,0x30,0x34,0x33,
-        0x34,0x30,0x34,0x34,0x34,0x30,0x34,0x35,
-        0x34,0x30,0x34,0x36,0x34,0x30,0x34,0x37,
-        0x34,0x30,0x34,0x38,0x34,0x30,0x34,0x39,
-        0x34,0x30,0x35,0x30,0x34,0x30,0x35,0x31,
-        0x34,0x30,0x35,0x32,0x34,0x30,0x35,0x33,
-        0x34,0x30,0x35,0x34,0x34,0x30,0x35,0x35,
-        0x34,0x30,0x35,0x36,0x34,0x30,0x35,0x37,
-        0x34,0x30,0x35,0x38,0x34,0x30,0x35,0x39,
-        0x34,0x30,0x36,0x30,0x34,0x30,0x36,0x31,
-        0x34,0x30,0x36,0x32,0x34,0x30,0x36,0x33,
-        0x34,0x30,0x36,0x34,0x34,0x30,0x36,0x35,
-        0x34,0x30,0x36,0x36,0x34,0x30,0x36,0x37,
-        0x34,0x30,0x36,0x38,0x34,0x30,0x36,0x39,
-        0x34,0x30,0x37,0x30,0x34,0x30,0x37,0x31,
-        0x34,0x30,0x37,0x32,0x34,0x30,0x37,0x33,
-        0x34,0x30,0x37,0x34,0x34,0x30,0x37,0x35,
-        0x34,0x30,0x37,0x36,0x34,0x30,0x37,0x37,
-        0x34,0x30,0x37,0x38,0x34,0x30,0x37,0x39,
-        0x34,0x30,0x38,0x30,0x34,0x30,0x38,0x31,
-        0x34,0x30,0x38,0x32,0x34,0x30,0x38,0x33,
-        0x34,0x30,0x38,0x34,0x34,0x30,0x38,0x35,
-        0x34,0x30,0x38,0x36,0x34,0x30,0x38,0x37,
-        0x34,0x30,0x38,0x38,0x34,0x30,0x38,0x39,
-        0x34,0x30,0x39,0x30,0x34,0x30,0x39,0x31,
-        0x34,0x30,0x39,0x32,0x34,0x30,0x39,0x33,
-        0x34,0x30,0x39,0x34,0x34,0x30,0x39,0x35};
-
-    static const int32_t gDigitCount[] = {
-        1,1,1,1,1,1,1,1,
-        1,1,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,2,2,2,2,
-        2,2,2,2,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        3,3,3,3,3,3,3,3,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4,
-        4,4,4,4,4,4,4,4};
-
-U_NAMESPACE_BEGIN
-
-
-IntDigitCountRange::IntDigitCountRange(int32_t min, int32_t max) {
-    fMin = min < 0 ? 0 : min;
-    fMax = max < fMin ? fMin : max;
-}
-
-int32_t
-IntDigitCountRange::pin(int32_t digitCount) const {
-    return digitCount < fMin ? fMin : (digitCount < fMax ? digitCount : fMax);
-}
-
-int32_t
-SmallIntFormatter::estimateDigitCount(
-        int32_t positiveValue, const IntDigitCountRange &range) {
-    if (positiveValue >= gMaxFastInt) {
-        return range.getMax();
-    }
-    return range.pin(gDigitCount[positiveValue]);
-}
-
-UBool
-SmallIntFormatter::canFormat(
-        int32_t positiveValue, const IntDigitCountRange &range) {
-    return (positiveValue < gMaxFastInt && range.getMin() <= 4);
-}
-
-UnicodeString &
-SmallIntFormatter::format(
-        int32_t smallPositiveValue,
-        const IntDigitCountRange &range,
-        UnicodeString &appendTo) {
-    int32_t digits = range.pin(gDigitCount[smallPositiveValue]);
-
-    // Always emit at least '0'
-    if (digits == 0) {
-        return appendTo.append((UChar) 0x30);
-    }
-    return appendTo.append(gDigits, ((smallPositiveValue  + 1) << 2) - digits, digits);
-}
-
-U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/smallintformatter.h b/deps/icu-small/source/i18n/smallintformatter.h
deleted file mode 100644
index 3373a9c35ffcec..00000000000000
--- a/deps/icu-small/source/i18n/smallintformatter.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* smallintformatter.h
-*
-* created on: 2015jan06
-* created by: Travis Keep
-*/
-
-#ifndef __SMALLINTFORMATTER_H__
-#define __SMALLINTFORMATTER_H__
-
-#include "unicode/uobject.h"
-#include "unicode/utypes.h"
-
-U_NAMESPACE_BEGIN
-
-class UnicodeString;
-
-/**
- * A representation an acceptable range of digit counts for integers.
- */
-class U_I18N_API IntDigitCountRange : public UMemory {
-public:
-    /**
-     * No constraints: 0 up to INT32_MAX
-     */
-    IntDigitCountRange() : fMin(0), fMax(INT32_MAX) { }
-    IntDigitCountRange(int32_t min, int32_t max);
-    int32_t pin(int32_t digitCount) const;
-    int32_t getMax() const { return fMax; }
-    int32_t getMin() const { return fMin; }
-private:
-    int32_t fMin;
-    int32_t fMax;
-};
-
-
-/**
- * A formatter for small, positive integers.
- */
-class U_I18N_API SmallIntFormatter : public UMemory {
-public:
-    /**
-     * Estimates the actual digit count needed to format positiveValue
-     * using the given range of digit counts.
-     * Returns a value that is at least the actual digit count needed.
-     *
-     * @param positiveValue the value to format
-     * @param range the acceptable range of digit counts.
-     */
-    static int32_t estimateDigitCount(
-            int32_t positiveValue, const IntDigitCountRange &range);
-
-    /**
-     * Returns TRUE if this class can format positiveValue using
-     * the given range of digit counts.
-     *
-     * @param positiveValue the value to format
-     * @param range the acceptable range of digit counts.
-     */
-    static UBool canFormat(
-            int32_t positiveValue, const IntDigitCountRange &range);
-
-    /**
-     * Formats positiveValue using the given range of digit counts.
-     * Always uses standard digits '0' through '9'. Formatted value is
-     * left padded with '0' as necessary to achieve minimum digit count.
-     * Does not produce any grouping separators or trailing decimal point.
-     * Calling format to format a value with a particular digit count range
-     * when canFormat indicates that the same value and digit count range
-     * cannot be formatted results in undefined behavior.
-     *
-     * @param positiveValue the value to format
-     * @param range the acceptable range of digit counts.
-     */
-    static UnicodeString &format(
-            int32_t positiveValue,
-            const IntDigitCountRange &range,
-            UnicodeString &appendTo);
-
-};
-
-U_NAMESPACE_END
-
-#endif  // __SMALLINTFORMATTER_H__
diff --git a/deps/icu-small/source/i18n/smpdtfmt.cpp b/deps/icu-small/source/i18n/smpdtfmt.cpp
index 27fbbd8f7a9ef5..b1b90882fceead 100644
--- a/deps/icu-small/source/i18n/smpdtfmt.cpp
+++ b/deps/icu-small/source/i18n/smpdtfmt.cpp
@@ -53,6 +53,7 @@
 #include "unicode/vtzone.h"
 #include "unicode/udisplaycontext.h"
 #include "unicode/brkiter.h"
+#include "unicode/rbnf.h"
 #include "uresimp.h"
 #include "olsontz.h"
 #include "patternprops.h"
@@ -72,6 +73,7 @@
 #include "cstr.h"
 #include "dayperiodrules.h"
 #include "tznames_impl.h"   // ZONE_NAME_U16_MAX
+#include "number_utypes.h"
 
 #if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)
 #include <stdio.h>
@@ -312,57 +314,6 @@ const NumberFormat *SimpleDateFormat::getNumberFormatByIndex(
     return &(**fSharedNumberFormatters[index]);
 }
 
-class SimpleDateFormatMutableNFNode {
- public:
-    const NumberFormat *key;
-    NumberFormat *value;
-    SimpleDateFormatMutableNFNode()
-            : key(NULL), value(NULL) { }
-    ~SimpleDateFormatMutableNFNode() {
-        delete value;
-    }
- private:
-    SimpleDateFormatMutableNFNode(const SimpleDateFormatMutableNFNode &);
-    SimpleDateFormatMutableNFNode &operator=(const SimpleDateFormatMutableNFNode &);
-};
-
-// Single threaded cache of non const NumberFormats. Designed to be stack
-// allocated and used for a single format call.
-class SimpleDateFormatMutableNFs : public UMemory {
- public:
-    SimpleDateFormatMutableNFs() {
-    }
-
-    // Returns a non-const clone of nf which can be safely modified.
-    // Subsequent calls with same nf will return the same non-const clone.
-    // This object maintains ownership of all returned non-const
-    // NumberFormat objects. On memory allocation error returns NULL.
-    // Caller must check for NULL return value.
-    NumberFormat *get(const NumberFormat *nf) {
-        if (nf == NULL) {
-            return NULL;
-        }
-        int32_t idx = 0;
-        while (nodes[idx].value) {
-            if (nf == nodes[idx].key) {
-                return nodes[idx].value;
-            }
-            ++idx;
-        }
-        U_ASSERT(idx < UDAT_FIELD_COUNT);
-        nodes[idx].key = nf;
-        nodes[idx].value = (NumberFormat *) nf->clone();
-        return nodes[idx].value;
-    }
- private:
-    // +1 extra for sentinel. If each field had its own NumberFormat, this
-    // cache would have to allocate UDAT_FIELD_COUNT mutable versions worst
-    // case.
-    SimpleDateFormatMutableNFNode nodes[UDAT_FIELD_COUNT + 1];
-    SimpleDateFormatMutableNFs(const SimpleDateFormatMutableNFs &);
-    SimpleDateFormatMutableNFs &operator=(const SimpleDateFormatMutableNFs &);
-};
-
 //----------------------------------------------------------------------
 
 SimpleDateFormat::~SimpleDateFormat()
@@ -374,6 +325,7 @@ SimpleDateFormat::~SimpleDateFormat()
     if (fTimeZoneFormat) {
         delete fTimeZoneFormat;
     }
+    freeFastNumberFormatters();
 
 #if !UCONFIG_NO_BREAK_ITERATION
     delete fCapitalizationBrkIter;
@@ -659,6 +611,10 @@ SimpleDateFormat& SimpleDateFormat::operator=(const SimpleDateFormat& other)
         }
     }
 
+    UErrorCode localStatus = U_ZERO_ERROR;
+    freeFastNumberFormatters();
+    initFastNumberFormatters(localStatus);
+
     return *this;
 }
 
@@ -908,7 +864,8 @@ SimpleDateFormat::initialize(const Locale& locale,
         fixNumberFormatForDates(*fNumberFormat);
         //fNumberFormat->setLenient(TRUE); // Java uses a custom DateNumberFormat to format/parse
 
-        initNumberFormatters(locale,status);
+        initNumberFormatters(locale, status);
+        initFastNumberFormatters(status);
 
     }
     else if (U_SUCCESS(status))
@@ -1023,11 +980,6 @@ SimpleDateFormat::_format(Calendar& cal, UnicodeString& appendTo,
     int32_t fieldNum = 0;
     UDisplayContext capitalizationContext = getContext(UDISPCTX_TYPE_CAPITALIZATION, status);
 
-    // Create temporary cache of mutable number format objects. This way
-    // subFormat won't have to clone the const NumberFormat for each field.
-    // if several fields share the same NumberFormat, which will almost
-    // always be the case, this is a big save.
-    SimpleDateFormatMutableNFs mutableNFs;
     // loop through the pattern string character by character
     for (int32_t i = 0; i < fPattern.length() && U_SUCCESS(status); ++i) {
         UChar ch = fPattern[i];
@@ -1035,7 +987,7 @@ SimpleDateFormat::_format(Calendar& cal, UnicodeString& appendTo,
         // Use subFormat() to format a repeated pattern character
         // when a different pattern or non-pattern character is seen
         if (ch != prevCh && count > 0) {
-            subFormat(appendTo, prevCh, count, capitalizationContext, fieldNum++, handler, *workCal, mutableNFs, status);
+            subFormat(appendTo, prevCh, count, capitalizationContext, fieldNum++, handler, *workCal, status);
             count = 0;
         }
         if (ch == QUOTE) {
@@ -1062,7 +1014,7 @@ SimpleDateFormat::_format(Calendar& cal, UnicodeString& appendTo,
 
     // Format the last item in the pattern, if any
     if (count > 0) {
-        subFormat(appendTo, prevCh, count, capitalizationContext, fieldNum++, handler, *workCal, mutableNFs, status);
+        subFormat(appendTo, prevCh, count, capitalizationContext, fieldNum++, handler, *workCal, status);
     }
 
     if (calClone != NULL) {
@@ -1257,6 +1209,43 @@ _appendSymbolWithMonthPattern(UnicodeString& dst, int32_t value, const UnicodeSt
 }
 
 //----------------------------------------------------------------------
+
+static number::LocalizedNumberFormatter*
+createFastFormatter(const DecimalFormat* df, int32_t minInt, int32_t maxInt) {
+    return new number::LocalizedNumberFormatter(
+            df->toNumberFormatter()
+                    .integerWidth(number::IntegerWidth::zeroFillTo(minInt).truncateAt(maxInt)));
+}
+
+void SimpleDateFormat::initFastNumberFormatters(UErrorCode& status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    auto* df = dynamic_cast<const DecimalFormat*>(fNumberFormat);
+    if (df == nullptr) {
+        return;
+    }
+    fFastNumberFormatters[SMPDTFMT_NF_1x10] = createFastFormatter(df, 1, 10);
+    fFastNumberFormatters[SMPDTFMT_NF_2x10] = createFastFormatter(df, 2, 10);
+    fFastNumberFormatters[SMPDTFMT_NF_3x10] = createFastFormatter(df, 3, 10);
+    fFastNumberFormatters[SMPDTFMT_NF_4x10] = createFastFormatter(df, 4, 10);
+    fFastNumberFormatters[SMPDTFMT_NF_2x2] = createFastFormatter(df, 2, 2);
+}
+
+void SimpleDateFormat::freeFastNumberFormatters() {
+    delete fFastNumberFormatters[SMPDTFMT_NF_1x10];
+    delete fFastNumberFormatters[SMPDTFMT_NF_2x10];
+    delete fFastNumberFormatters[SMPDTFMT_NF_3x10];
+    delete fFastNumberFormatters[SMPDTFMT_NF_4x10];
+    delete fFastNumberFormatters[SMPDTFMT_NF_2x2];
+    fFastNumberFormatters[SMPDTFMT_NF_1x10] = nullptr;
+    fFastNumberFormatters[SMPDTFMT_NF_2x10] = nullptr;
+    fFastNumberFormatters[SMPDTFMT_NF_3x10] = nullptr;
+    fFastNumberFormatters[SMPDTFMT_NF_4x10] = nullptr;
+    fFastNumberFormatters[SMPDTFMT_NF_2x2] = nullptr;
+}
+
+
 void
 SimpleDateFormat::initNumberFormatters(const Locale &locale,UErrorCode &status) {
     if (U_FAILURE(status)) {
@@ -1406,7 +1395,6 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
                             int32_t fieldNum,
                             FieldPositionHandler& handler,
                             Calendar& cal,
-                            SimpleDateFormatMutableNFs &mutableNFs,
                             UErrorCode& status) const
 {
     if (U_FAILURE(status)) {
@@ -1419,7 +1407,7 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
     UDateFormatField patternCharIndex = DateFormatSymbols::getPatternCharIndex(ch);
     const int32_t maxIntCount = 10;
     int32_t beginOffset = appendTo.length();
-    NumberFormat *currentNumberFormat;
+    const NumberFormat *currentNumberFormat;
     DateFormatSymbols::ECapitalizationContextUsageType capContextUsageType = DateFormatSymbols::kCapContextUsageOther;
 
     UBool isHebrewCalendar = (uprv_strcmp(cal.getType(),"hebrew") == 0);
@@ -1444,9 +1432,9 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
         return;
     }
 
-    currentNumberFormat = mutableNFs.get(getNumberFormatByIndex(patternCharIndex));
+    currentNumberFormat = getNumberFormatByIndex(patternCharIndex);
     if (currentNumberFormat == NULL) {
-        status = U_MEMORY_ALLOCATION_ERROR;
+        status = U_INTERNAL_PROGRAM_ERROR;
         return;
     }
     UnicodeString hebr("hebr", 4, US_INV);
@@ -1566,18 +1554,15 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
     case UDAT_FRACTIONAL_SECOND_FIELD:
         // Fractional seconds left-justify
         {
-            currentNumberFormat->setMinimumIntegerDigits((count > 3) ? 3 : count);
-            currentNumberFormat->setMaximumIntegerDigits(maxIntCount);
+            int32_t minDigits = (count > 3) ? 3 : count;
             if (count == 1) {
                 value /= 100;
             } else if (count == 2) {
                 value /= 10;
             }
-            FieldPosition p(FieldPosition::DONT_CARE);
-            currentNumberFormat->format(value, appendTo, p);
+            zeroPaddingNumber(currentNumberFormat, appendTo, value, minDigits, maxIntCount);
             if (count > 3) {
-                currentNumberFormat->setMinimumIntegerDigits(count - 3);
-                currentNumberFormat->format((int32_t)0, appendTo, p);
+                zeroPaddingNumber(currentNumberFormat, appendTo, 0, count - 3, maxIntCount);
             }
         }
         break;
@@ -1695,100 +1680,101 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
             UnicodeString zoneString(zsbuf, 0, UPRV_LENGTHOF(zsbuf));
             const TimeZone& tz = cal.getTimeZone();
             UDate date = cal.getTime(status);
+            const TimeZoneFormat *tzfmt = tzFormat(status);
             if (U_SUCCESS(status)) {
                 if (patternCharIndex == UDAT_TIMEZONE_FIELD) {
                     if (count < 4) {
                         // "z", "zz", "zzz"
-                        tzFormat()->format(UTZFMT_STYLE_SPECIFIC_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_SPECIFIC_SHORT, tz, date, zoneString);
                         capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneShort;
                     } else {
                         // "zzzz" or longer
-                        tzFormat()->format(UTZFMT_STYLE_SPECIFIC_LONG, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_SPECIFIC_LONG, tz, date, zoneString);
                         capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneLong;
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_RFC_FIELD) {
                     if (count < 4) {
                         // "Z"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL, tz, date, zoneString);
                     } else if (count == 5) {
                         // "ZZZZZ"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_EXTENDED_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_EXTENDED_FULL, tz, date, zoneString);
                     } else {
                         // "ZZ", "ZZZ", "ZZZZ"
-                        tzFormat()->format(UTZFMT_STYLE_LOCALIZED_GMT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_LOCALIZED_GMT, tz, date, zoneString);
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_GENERIC_FIELD) {
                     if (count == 1) {
                         // "v"
-                        tzFormat()->format(UTZFMT_STYLE_GENERIC_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_GENERIC_SHORT, tz, date, zoneString);
                         capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneShort;
                     } else if (count == 4) {
                         // "vvvv"
-                        tzFormat()->format(UTZFMT_STYLE_GENERIC_LONG, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_GENERIC_LONG, tz, date, zoneString);
                         capContextUsageType = DateFormatSymbols::kCapContextUsageMetazoneLong;
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_SPECIAL_FIELD) {
                     if (count == 1) {
                         // "V"
-                        tzFormat()->format(UTZFMT_STYLE_ZONE_ID_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ZONE_ID_SHORT, tz, date, zoneString);
                     } else if (count == 2) {
                         // "VV"
-                        tzFormat()->format(UTZFMT_STYLE_ZONE_ID, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ZONE_ID, tz, date, zoneString);
                     } else if (count == 3) {
                         // "VVV"
-                        tzFormat()->format(UTZFMT_STYLE_EXEMPLAR_LOCATION, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_EXEMPLAR_LOCATION, tz, date, zoneString);
                     } else if (count == 4) {
                         // "VVVV"
-                        tzFormat()->format(UTZFMT_STYLE_GENERIC_LOCATION, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_GENERIC_LOCATION, tz, date, zoneString);
                         capContextUsageType = DateFormatSymbols::kCapContextUsageZoneLong;
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD) {
                     if (count == 1) {
                         // "O"
-                        tzFormat()->format(UTZFMT_STYLE_LOCALIZED_GMT_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_LOCALIZED_GMT_SHORT, tz, date, zoneString);
                     } else if (count == 4) {
                         // "OOOO"
-                        tzFormat()->format(UTZFMT_STYLE_LOCALIZED_GMT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_LOCALIZED_GMT, tz, date, zoneString);
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_ISO_FIELD) {
                     if (count == 1) {
                         // "X"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_SHORT, tz, date, zoneString);
                     } else if (count == 2) {
                         // "XX"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_FIXED, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_FIXED, tz, date, zoneString);
                     } else if (count == 3) {
                         // "XXX"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_EXTENDED_FIXED, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_EXTENDED_FIXED, tz, date, zoneString);
                     } else if (count == 4) {
                         // "XXXX"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_FULL, tz, date, zoneString);
                     } else if (count == 5) {
                         // "XXXXX"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_EXTENDED_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_EXTENDED_FULL, tz, date, zoneString);
                     }
                 }
                 else if (patternCharIndex == UDAT_TIMEZONE_ISO_LOCAL_FIELD) {
                     if (count == 1) {
                         // "x"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT, tz, date, zoneString);
                     } else if (count == 2) {
                         // "xx"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED, tz, date, zoneString);
                     } else if (count == 3) {
                         // "xxx"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED, tz, date, zoneString);
                     } else if (count == 4) {
                         // "xxxx"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL, tz, date, zoneString);
                     } else if (count == 5) {
                         // "xxxxx"
-                        tzFormat()->format(UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL, tz, date, zoneString);
+                        tzfmt->format(UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL, tz, date, zoneString);
                     }
                 }
                 else {
@@ -1855,7 +1841,7 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
         if (toAppend == NULL || toAppend->isBogus()) {
             // Reformat with identical arguments except ch, now changed to 'a'.
             subFormat(appendTo, 0x61, count, capitalizationContext, fieldNum,
-                      handler, cal, mutableNFs, status);
+                      handler, cal, status);
         } else {
             appendTo += *toAppend;
         }
@@ -1876,7 +1862,7 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
             // Data doesn't exist for the locale we're looking for.
             // Falling back to am/pm.
             subFormat(appendTo, 0x61, count, capitalizationContext, fieldNum,
-                      handler, cal, mutableNFs, status);
+                      handler, cal, status);
             break;
         }
 
@@ -1947,7 +1933,7 @@ SimpleDateFormat::subFormat(UnicodeString &appendTo,
             periodType == DayPeriodRules::DAYPERIOD_PM ||
             toAppend->isBogus()) {
             subFormat(appendTo, 0x61, count, capitalizationContext, fieldNum,
-                      handler, cal, mutableNFs, status);
+                      handler, cal, status);
         }
         else {
             appendTo += *toAppend;
@@ -2004,6 +1990,11 @@ void SimpleDateFormat::adoptNumberFormat(NumberFormat *formatToAdopt) {
         freeSharedNumberFormatters(fSharedNumberFormatters);
         fSharedNumberFormatters = NULL;
     }
+
+    // Also re-compute the fast formatters.
+    UErrorCode localStatus = U_ZERO_ERROR;
+    freeFastNumberFormatters();
+    initFastNumberFormatters(localStatus);
 }
 
 void SimpleDateFormat::adoptNumberFormat(const UnicodeString& fields, NumberFormat *formatToAdopt, UErrorCode &status){
@@ -2055,16 +2046,58 @@ SimpleDateFormat::getNumberFormatForField(UChar field) const {
 //----------------------------------------------------------------------
 void
 SimpleDateFormat::zeroPaddingNumber(
-        NumberFormat *currentNumberFormat,
+        const NumberFormat *currentNumberFormat,
         UnicodeString &appendTo,
         int32_t value, int32_t minDigits, int32_t maxDigits) const
 {
-    if (currentNumberFormat!=NULL) {
+    const number::LocalizedNumberFormatter* fastFormatter = nullptr;
+    // NOTE: This uses the heuristic that these five min/max int settings account for the vast majority
+    // of SimpleDateFormat number formatting cases at the time of writing (ICU 62).
+    if (currentNumberFormat == fNumberFormat) {
+        if (maxDigits == 10) {
+            if (minDigits == 1) {
+                fastFormatter = fFastNumberFormatters[SMPDTFMT_NF_1x10];
+            } else if (minDigits == 2) {
+                fastFormatter = fFastNumberFormatters[SMPDTFMT_NF_2x10];
+            } else if (minDigits == 3) {
+                fastFormatter = fFastNumberFormatters[SMPDTFMT_NF_3x10];
+            } else if (minDigits == 4) {
+                fastFormatter = fFastNumberFormatters[SMPDTFMT_NF_4x10];
+            }
+        } else if (maxDigits == 2) {
+            if (minDigits == 2) {
+                fastFormatter = fFastNumberFormatters[SMPDTFMT_NF_2x2];
+            }
+        }
+    }
+    if (fastFormatter != nullptr) {
+        // Can use fast path
+        number::impl::UFormattedNumberData result;
+        result.quantity.setToInt(value);
+        UErrorCode localStatus = U_ZERO_ERROR;
+        fastFormatter->formatImpl(&result, localStatus);
+        if (U_FAILURE(localStatus)) {
+            return;
+        }
+        appendTo.append(result.string.toTempUnicodeString());
+        return;
+    }
+
+    // Check for RBNF (no clone necessary)
+    auto* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(currentNumberFormat);
+    if (rbnf != nullptr) {
         FieldPosition pos(FieldPosition::DONT_CARE);
+        rbnf->format(value, appendTo, pos);  // 3rd arg is there to speed up processing
+        return;
+    }
 
-        currentNumberFormat->setMinimumIntegerDigits(minDigits);
-        currentNumberFormat->setMaximumIntegerDigits(maxDigits);
-        currentNumberFormat->format(value, appendTo, pos);  // 3rd arg is there to speed up processing
+    // Fall back to slow path (clone and mutate the NumberFormat)
+    if (currentNumberFormat != nullptr) {
+        FieldPosition pos(FieldPosition::DONT_CARE);
+        LocalPointer<NumberFormat> nf(dynamic_cast<NumberFormat*>(currentNumberFormat->clone()));
+        nf->setMinimumIntegerDigits(minDigits);
+        nf->setMaximumIntegerDigits(maxDigits);
+        nf->format(value, appendTo, pos);  // 3rd arg is there to speed up processing
     }
 }
 
@@ -2131,7 +2164,6 @@ SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition&
     int32_t saveHebrewMonth = -1;
     int32_t count = 0;
     UTimeZoneFormatTimeType tzTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
-    SimpleDateFormatMutableNFs mutableNFs;
 
     // For parsing abutting numeric fields. 'abutPat' is the
     // offset into 'pattern' of the first of 2 or more abutting
@@ -2225,7 +2257,7 @@ SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition&
                 }
 
                 pos = subParse(text, pos, ch, count,
-                               TRUE, FALSE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter, &tzTimeType, mutableNFs);
+                               TRUE, FALSE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter, &tzTimeType);
 
                 // If the parse fails anywhere in the run, back up to the
                 // start of the run and retry.
@@ -2240,7 +2272,7 @@ SimpleDateFormat::parse(const UnicodeString& text, Calendar& cal, ParsePosition&
             // fields.
             else if (ch != 0x6C) { // pattern char 'l' (SMALL LETTER L) just gets ignored
                 int32_t s = subParse(text, pos, ch, count,
-                               FALSE, TRUE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter, &tzTimeType, mutableNFs, &dayPeriodInt);
+                               FALSE, TRUE, ambiguousYear, saveHebrewMonth, *workCal, i, numericLeapMonthFormatter, &tzTimeType, &dayPeriodInt);
 
                 if (s == -pos-1) {
                     // era not present, in special cases allow this to continue
@@ -2858,7 +2890,7 @@ SimpleDateFormat::set2DigitYearStart(UDate d, UErrorCode& status)
  */
 int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UChar ch, int32_t count,
                            UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
-                           int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType, SimpleDateFormatMutableNFs &mutableNFs,
+                           int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType,
                            int32_t *dayPeriod) const
 {
     Formattable number;
@@ -2868,7 +2900,7 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
     UErrorCode status = U_ZERO_ERROR;
     ParsePosition pos(0);
     UDateFormatField patternCharIndex = DateFormatSymbols::getPatternCharIndex(ch);
-    NumberFormat *currentNumberFormat;
+    const NumberFormat *currentNumberFormat;
     UnicodeString temp;
     UBool gotNumber = FALSE;
 
@@ -2880,7 +2912,7 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
         return -start;
     }
 
-    currentNumberFormat = mutableNFs.get(getNumberFormatByIndex(patternCharIndex));
+    currentNumberFormat = getNumberFormatByIndex(patternCharIndex);
     if (currentNumberFormat == NULL) {
         return -start;
     }
@@ -3393,31 +3425,41 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
     case UDAT_TIMEZONE_FIELD: // 'z'
         {
             UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_SPECIFIC_SHORT : UTZFMT_STYLE_SPECIFIC_LONG;
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
-        }
+            return -start;
+    }
         break;
     case UDAT_TIMEZONE_RFC_FIELD: // 'Z'
         {
             UTimeZoneFormatStyle style = (count < 4) ?
                 UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL : ((count == 5) ? UTZFMT_STYLE_ISO_EXTENDED_FULL: UTZFMT_STYLE_LOCALIZED_GMT);
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
     case UDAT_TIMEZONE_GENERIC_FIELD: // 'v'
         {
             UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_GENERIC_SHORT : UTZFMT_STYLE_GENERIC_LONG;
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
@@ -3438,20 +3480,26 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
                 style = UTZFMT_STYLE_GENERIC_LOCATION;
                 break;
             }
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
     case UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD: // 'O'
         {
             UTimeZoneFormatStyle style = (count < 4) ? UTZFMT_STYLE_LOCALIZED_GMT_SHORT : UTZFMT_STYLE_LOCALIZED_GMT;
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
@@ -3475,10 +3523,13 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
                 style = UTZFMT_STYLE_ISO_EXTENDED_FULL;
                 break;
             }
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
@@ -3502,10 +3553,13 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
                 style = UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL;
                 break;
             }
-            TimeZone *tz  = tzFormat()->parse(style, text, pos, tzTimeType);
-            if (tz != NULL) {
-                cal.adoptTimeZone(tz);
-                return pos.getIndex();
+            const TimeZoneFormat *tzfmt = tzFormat(status);
+            if (U_SUCCESS(status)) {
+                TimeZone *tz = tzfmt->parse(style, text, pos, tzTimeType);
+                if (tz != NULL) {
+                    cal.adoptTimeZone(tz);
+                    return pos.getIndex();
+                }
             }
             return -start;
         }
@@ -3539,7 +3593,7 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
         U_ASSERT(dayPeriod != NULL);
         int32_t ampmStart = subParse(text, start, 0x61, count,
                            obeyCount, allowNegative, ambiguousYear, saveHebrewMonth, cal,
-                           patLoc, numericLeapMonthFormatter, tzTimeType, mutableNFs);
+                           patLoc, numericLeapMonthFormatter, tzTimeType);
 
         if (ampmStart > 0) {
             return ampmStart;
@@ -3686,7 +3740,7 @@ void SimpleDateFormat::parseInt(const UnicodeString& text,
                                 Formattable& number,
                                 ParsePosition& pos,
                                 UBool allowNegative,
-                                NumberFormat *fmt) const {
+                                const NumberFormat *fmt) const {
     parseInt(text, number, -1, pos, allowNegative,fmt);
 }
 
@@ -3698,18 +3752,21 @@ void SimpleDateFormat::parseInt(const UnicodeString& text,
                                 int32_t maxDigits,
                                 ParsePosition& pos,
                                 UBool allowNegative,
-                                NumberFormat *fmt) const {
+                                const NumberFormat *fmt) const {
     UnicodeString oldPrefix;
-    DecimalFormat* df = NULL;
-    if (!allowNegative && (df = dynamic_cast<DecimalFormat*>(fmt)) != NULL) {
-        df->getNegativePrefix(oldPrefix);
+    auto* fmtAsDF = dynamic_cast<const DecimalFormat*>(fmt);
+    LocalPointer<DecimalFormat> df;
+    if (!allowNegative && fmtAsDF != nullptr) {
+        df.adoptInstead(dynamic_cast<DecimalFormat*>(fmtAsDF->clone()));
+        if (df.isNull()) {
+            // Memory allocation error
+            return;
+        }
         df->setNegativePrefix(UnicodeString(TRUE, SUPPRESS_NEGATIVE_PREFIX, -1));
+        fmt = df.getAlias();
     }
     int32_t oldPos = pos.getIndex();
     fmt->parse(text, number, pos);
-    if (df != NULL) {
-        df->setNegativePrefix(oldPrefix);
-    }
 
     if (maxDigits > 0) {
         // adjust the result to fit into
@@ -3856,7 +3913,13 @@ SimpleDateFormat::setDateFormatSymbols(const DateFormatSymbols& newFormatSymbols
 //----------------------------------------------------------------------
 const TimeZoneFormat*
 SimpleDateFormat::getTimeZoneFormat(void) const {
-    return (const TimeZoneFormat*)tzFormat();
+    // TimeZoneFormat initialization might fail when out of memory.
+    // If we always initialize TimeZoneFormat instance, we can return
+    // such status there. For now, this implementation lazily instantiates
+    // a TimeZoneFormat for performance optimization reasons, but cannot
+    // propagate such error (probably just out of memory case) to the caller.
+    UErrorCode status = U_ZERO_ERROR;
+    return (const TimeZoneFormat*)tzFormat(status);
 }
 
 //----------------------------------------------------------------------
@@ -4123,12 +4186,11 @@ SimpleDateFormat::skipUWhiteSpace(const UnicodeString& text, int32_t pos) const
 
 // Lazy TimeZoneFormat instantiation, semantically const.
 TimeZoneFormat *
-SimpleDateFormat::tzFormat() const {
+SimpleDateFormat::tzFormat(UErrorCode &status) const {
     if (fTimeZoneFormat == NULL) {
         umtx_lock(&LOCK);
         {
             if (fTimeZoneFormat == NULL) {
-                UErrorCode status = U_ZERO_ERROR;
                 TimeZoneFormat *tzfmt = TimeZoneFormat::createInstance(fLocale, status);
                 if (U_FAILURE(status)) {
                     return NULL;
diff --git a/deps/icu-small/source/i18n/timezone.cpp b/deps/icu-small/source/i18n/timezone.cpp
index e662bf7674b9f4..f7f45c7d3eeffd 100644
--- a/deps/icu-small/source/i18n/timezone.cpp
+++ b/deps/icu-small/source/i18n/timezone.cpp
@@ -739,8 +739,7 @@ class TZEnumeration : public StringEnumeration {
         len = mapLen;
     }
 
-    UBool getID(int32_t i) {
-        UErrorCode ec = U_ZERO_ERROR;
+    UBool getID(int32_t i, UErrorCode& ec) {
         int32_t idLen = 0;
         const UChar* id = NULL;
         UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec);
@@ -930,7 +929,7 @@ class TZEnumeration : public StringEnumeration {
 
     virtual const UnicodeString* snext(UErrorCode& status) {
         if (U_SUCCESS(status) && map != NULL && pos < len) {
-            getID(map[pos]);
+            getID(map[pos], status);
             ++pos;
             return &unistr;
         }
diff --git a/deps/icu-small/source/i18n/ucln_in.h b/deps/icu-small/source/i18n/ucln_in.h
index 40a5c36d87a9f7..318eafc143c968 100644
--- a/deps/icu-small/source/i18n/ucln_in.h
+++ b/deps/icu-small/source/i18n/ucln_in.h
@@ -26,6 +26,7 @@ as the functions are suppose to be called.
 It's usually best to have child dependencies called first. */
 typedef enum ECleanupI18NType {
     UCLN_I18N_START = -1,
+    UCLN_I18N_NUMBER_SKELETONS,
     UCLN_I18N_CURRENCY_SPACING,
     UCLN_I18N_SPOOF,
     UCLN_I18N_SPOOFDATA,
diff --git a/deps/icu-small/source/i18n/unicode/compactdecimalformat.h b/deps/icu-small/source/i18n/unicode/compactdecimalformat.h
index d682d2d0e74278..7dc92f610062f4 100644
--- a/deps/icu-small/source/i18n/unicode/compactdecimalformat.h
+++ b/deps/icu-small/source/i18n/unicode/compactdecimalformat.h
@@ -84,7 +84,7 @@ class U_I18N_API CompactDecimalFormat : public DecimalFormat {
      * Destructor.
      * @stable ICU 51
      */
-    virtual ~CompactDecimalFormat();
+    ~CompactDecimalFormat() U_OVERRIDE;
 
     /**
      * Assignment operator.
@@ -101,245 +101,21 @@ class U_I18N_API CompactDecimalFormat : public DecimalFormat {
      * @return    a polymorphic copy of this CompactDecimalFormat.
      * @stable ICU 51
      */
-    virtual Format* clone() const;
-
-    /**
-     * Return TRUE if the given Format objects are semantically equal.
-     * Objects of different subclasses are considered unequal.
-     *
-     * @param other    the object to be compared with.
-     * @return         TRUE if the given Format objects are semantically equal.
-     * @stable ICU 51
-     */
-    virtual UBool operator==(const Format& other) const;
-
+    Format* clone() const U_OVERRIDE;
 
     using DecimalFormat::format;
 
     /**
-     * Format a double or long number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @return          Reference to 'appendTo' parameter.
-     * @stable ICU 51
-     */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
-
-    /**
-     * Format a double or long number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @param status
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
-
-    /**
-     * Format a double or long number using base-10 representation.
-     * Currently sets status to U_UNSUPPORTED_ERROR.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     *                  Can be NULL.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
-
-    /**
-     * Format a long number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @return          Reference to 'appendTo' parameter.
-     * @stable ICU 56
-     */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
-
-    /**
-     * Format a long number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
-
-    /**
-     * Format a long number using base-10 representation.
-     * Currently sets status to U_UNSUPPORTED_ERROR
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     *                  Can be NULL.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
-
-    /**
-     * Format an int64 number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @return          Reference to 'appendTo' parameter.
+     * CompactDecimalFormat does not support parsing. This implementation
+     * does nothing.
+     * @param text           Unused.
+     * @param result         Does not change.
+     * @param parsePosition  Does not change.
+     * @see Formattable
      * @stable ICU 51
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
-
-    /**
-     * Format an int64 number using base-10 representation.
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
-
-    /**
-     * Format an int64 number using base-10 representation.
-     * Currently sets status to U_UNSUPPORTED_ERROR
-     *
-     * @param number    The value to be formatted.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     *                  Can be NULL.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
-
-    /**
-     * Format a decimal number. Currently sets status to U_UNSUPPORTED_ERROR
-     * The syntax of the unformatted number is a "numeric string"
-     * as defined in the Decimal Arithmetic Specification, available at
-     * http://speleotrove.com/decimal
-     *
-     * @param number    The unformatted number, as a string.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     *                  Can be NULL.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(StringPiece number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
-
-    /**
-     * Format a decimal number. Currently sets status to U_UNSUPPORTED_ERROR
-     * The number is a DigitList wrapper onto a floating point decimal number.
-     * The default implementation in NumberFormat converts the decimal number
-     * to a double and formats that.
-     *
-     * @param number    The number, a DigitList format Decimal Floating Point.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
-
-    /**
-     * Format a decimal number. Currently sets status to U_UNSUPPORTED_ERROR.
-     * The number is a DigitList wrapper onto a floating point decimal number.
-     * The default implementation in NumberFormat converts the decimal number
-     * to a double and formats that.
-     *
-     * @param number    The number, a DigitList format Decimal Floating Point.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode& status) const;
-
-   /**
-    * CompactDecimalFormat does not support parsing. This implementation
-    * does nothing.
-    * @param text           Unused.
-    * @param result         Does not change.
-    * @param parsePosition  Does not change.
-    * @see Formattable
-    * @stable ICU 51
-    */
-    virtual void parse(const UnicodeString& text,
-                       Formattable& result,
-                       ParsePosition& parsePosition) const;
+    void parse(const UnicodeString& text, Formattable& result,
+               ParsePosition& parsePosition) const U_OVERRIDE;
 
     /**
      * CompactDecimalFormat does not support parsing. This implementation
@@ -350,10 +126,9 @@ class U_I18N_API CompactDecimalFormat : public DecimalFormat {
      * @param status    Always set to U_UNSUPPORTED_ERROR.
      * @stable ICU 51
      */
-    virtual void parse(const UnicodeString& text,
-                       Formattable& result,
-                       UErrorCode& status) const;
+    void parse(const UnicodeString& text, Formattable& result, UErrorCode& status) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Parses text from the given string as a currency amount.  Unlike
      * the parse() method, this method will attempt to parse a generic
@@ -374,8 +149,8 @@ class U_I18N_API CompactDecimalFormat : public DecimalFormat {
      *             the parsed currency; if parse fails, this is NULL.
      * @internal
      */
-    virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
-                                          ParsePosition& pos) const;
+    CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Return the class ID for this class.  This is useful only for
@@ -401,18 +176,10 @@ class U_I18N_API CompactDecimalFormat : public DecimalFormat {
      *                  other classes have different class IDs.
      * @stable ICU 51
      */
-    virtual UClassID getDynamicClassID() const;
-
-private:
-
-    const UHashtable* _unitsByVariant;
-    const double* _divisors;
-    PluralRules* _pluralRules;
-
-    // Default constructor not implemented.
-    CompactDecimalFormat(const DecimalFormat &, const UHashtable* unitsByVariant, const double* divisors, PluralRules* pluralRules);
+    UClassID getDynamicClassID() const U_OVERRIDE;
 
-    UBool eqHelper(const CompactDecimalFormat& that) const;
+  private:
+    CompactDecimalFormat(const Locale& inLocale, UNumberCompactStyle style, UErrorCode& status);
 };
 
 U_NAMESPACE_END
diff --git a/deps/icu-small/source/i18n/unicode/currunit.h b/deps/icu-small/source/i18n/unicode/currunit.h
index e7e0dc72da8292..d5bc4aa6d6d482 100644
--- a/deps/icu-small/source/i18n/unicode/currunit.h
+++ b/deps/icu-small/source/i18n/unicode/currunit.h
@@ -44,8 +44,9 @@ class U_I18N_API CurrencyUnit: public MeasureUnit {
 
     /**
      * Construct an object with the given ISO currency code.
-     * @param isoCode the 3-letter ISO 4217 currency code; must not be
-     * NULL and must have length 3
+     * @param isoCode the 3-letter ISO 4217 currency code; must have
+     * length 3 and need not be NUL-terminated. If NULL, the currency
+     * is initialized to the unknown currency XXX.
      * @param ec input-output error code. If the isoCode is invalid,
      * then this will be set to a failing value.
      * @stable ICU 3.0
diff --git a/deps/icu-small/source/i18n/unicode/dcfmtsym.h b/deps/icu-small/source/i18n/unicode/dcfmtsym.h
index e58befa31bda88..2f824cec3087f5 100644
--- a/deps/icu-small/source/i18n/unicode/dcfmtsym.h
+++ b/deps/icu-small/source/i18n/unicode/dcfmtsym.h
@@ -406,9 +406,12 @@ class U_I18N_API DecimalFormatSymbols : public UObject {
      * returning a const reference to one of the symbol strings.
      * The returned reference becomes invalid when the symbol is changed
      * or when the DecimalFormatSymbols are destroyed.
-     * ### TODO markus 2002oct11: Consider proposing getConstSymbol() to be really public.
      * Note: moved #ifndef U_HIDE_INTERNAL_API after this, since this is needed for inline in DecimalFormat
      *
+     * This is not currently stable API, but if you think it should be stable,
+     * post a comment on the following ticket and the ICU team will take a look:
+     * http://bugs.icu-project.org/trac/ticket/13580
+     *
      * @param symbol Constant to indicate a number format symbol.
      * @return the format symbol by the param 'symbol'
      * @internal
@@ -422,6 +425,10 @@ class U_I18N_API DecimalFormatSymbols : public UObject {
      * to accessing the symbol from getConstSymbol with the corresponding
      * key, such as kZeroDigitSymbol or kOneDigitSymbol.
      *
+     * This is not currently stable API, but if you think it should be stable,
+     * post a comment on the following ticket and the ICU team will take a look:
+     * http://bugs.icu-project.org/trac/ticket/13580
+     *
      * @param digit The digit, an integer between 0 and 9 inclusive.
      *              If outside the range 0 to 9, the zero digit is returned.
      * @return the format symbol for the given digit.
diff --git a/deps/icu-small/source/i18n/unicode/decimfmt.h b/deps/icu-small/source/i18n/unicode/decimfmt.h
index b062208d9b1f93..3747f510f79c79 100644
--- a/deps/icu-small/source/i18n/unicode/decimfmt.h
+++ b/deps/icu-small/source/i18n/unicode/decimfmt.h
@@ -43,28 +43,25 @@
 #include "unicode/curramt.h"
 #include "unicode/enumset.h"
 
-#ifndef U_HIDE_INTERNAL_API
-/**
- * \def UNUM_DECIMALFORMAT_INTERNAL_SIZE
- * @internal
- */
-#if UCONFIG_FORMAT_FASTPATHS_49
-#define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16
-#endif
-#endif  /* U_HIDE_INTERNAL_API */
-
 U_NAMESPACE_BEGIN
 
-class DigitList;
 class CurrencyPluralInfo;
-class Hashtable;
-class UnicodeSet;
-class FieldPositionHandler;
-class DecimalFormatStaticSets;
-class FixedDecimal;
-class DecimalFormatImpl;
-class PluralRules;
-class VisibleDigitsWithExponent;
+class CompactDecimalFormat;
+
+namespace number {
+class LocalizedNumberFormatter;
+class FormattedNumber;
+namespace impl {
+class DecimalQuantity;
+struct DecimalFormatFields;
+}
+}
+
+namespace numparse {
+namespace impl {
+class NumberParserImpl;
+}
+}
 
 // explicit template instantiation. see digitlst.h
 // (When building DLLs for Windows this is required.)
@@ -672,17 +669,14 @@ template class U_I18N_API    EnumSet<UNumberFormatAttribute,
  * subclasses, such code will not necessarily work and will not be
  * guaranteed to work stably from release to release.
  */
-class U_I18N_API DecimalFormat: public NumberFormat {
-public:
+class U_I18N_API DecimalFormat : public NumberFormat {
+  public:
     /**
      * Pad position.
      * @stable ICU 2.4
      */
     enum EPadPosition {
-        kPadBeforePrefix,
-        kPadAfterPrefix,
-        kPadBeforeSuffix,
-        kPadAfterSuffix
+        kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix
     };
 
     /**
@@ -720,8 +714,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                  pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(const UnicodeString& pattern,
-                  UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, UErrorCode& status);
 
     /**
      * Create a DecimalFormat from the given pattern and symbols.
@@ -744,11 +737,10 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
 
 #ifndef U_HIDE_INTERNAL_API
+
     /**
      * This API is for ICU use only.
      * Create a DecimalFormat from the given pattern, symbols, and style.
@@ -761,20 +753,29 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                          pattern is invalid this will be set to a failure code.
      * @internal
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UNumberFormatStyle style,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                  UNumberFormatStyle style, UErrorCode& status);
 
 #if UCONFIG_HAVE_PARSEALLINPUT
+
     /**
      * @internal
      */
     void setParseAllInput(UNumberFormatAttributeValue value);
+
 #endif
 
 #endif  /* U_HIDE_INTERNAL_API */
 
+  private:
+
+    /**
+     * Internal constructor for DecimalFormat; sets up internal fields. All public constructors should
+     * call this constructor.
+     */
+    DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
+
+  public:
 
     /**
      * Set an integer attribute on this DecimalFormat.
@@ -786,9 +787,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) )
      * @stable ICU 51
      */
-    virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
-                                       int32_t newvalue,
-                                       UErrorCode &status);
+    virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status);
 
     /**
      * Get an integer
@@ -799,8 +798,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return the attribute value. Undefined if there is an error.
      * @stable ICU 51
      */
-    virtual int32_t getAttribute( UNumberFormatAttribute attr,
-                                  UErrorCode &status) const;
+    virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const;
 
 
     /**
@@ -809,7 +807,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see getGroupingUsed
      * @stable ICU 53
      */
-    virtual void setGroupingUsed(UBool newValue);
+    void setGroupingUsed(UBool newValue) U_OVERRIDE;
 
     /**
      * Sets whether or not numbers should be parsed as integers only.
@@ -818,18 +816,16 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see isParseIntegerOnly
      * @stable ICU 53
      */
-    virtual void setParseIntegerOnly(UBool value);
+    void setParseIntegerOnly(UBool value) U_OVERRIDE;
 
     /**
-     * Set a particular UDisplayContext value in the formatter, such as
-     * UDISPCTX_CAPITALIZATION_FOR_STANDALONE.
-     * @param value The UDisplayContext value to set.
-     * @param status Input/output status. If at entry this indicates a failure
-     *               status, the function will do nothing; otherwise this will be
-     *               updated with any new status from the function.
-     * @stable ICU 53
+     * Sets whether lenient parsing should be enabled (it is off by default).
+     *
+     * @param enable \c TRUE if lenient parsing should be used,
+     *               \c FALSE otherwise.
+     * @stable ICU 4.8
      */
-    virtual void setContext(UDisplayContext value, UErrorCode& status);
+    void setLenient(UBool enable) U_OVERRIDE;
 
     /**
      * Create a DecimalFormat from the given pattern and symbols.
@@ -853,10 +849,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    DecimalFormatSymbols* symbolsToAdopt,
-                    UParseError& parseError,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
+                  UParseError& parseError, UErrorCode& status);
+
     /**
      * Create a DecimalFormat from the given pattern and symbols.
      * Use this constructor when you need to completely customize the
@@ -877,9 +872,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                          pattern is invalid this will be set to a failure code.
      * @stable ICU 2.0
      */
-    DecimalFormat(  const UnicodeString& pattern,
-                    const DecimalFormatSymbols& symbols,
-                    UErrorCode& status);
+    DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status);
 
     /**
      * Copy constructor.
@@ -901,7 +894,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * Destructor.
      * @stable ICU 2.0
      */
-    virtual ~DecimalFormat();
+    ~DecimalFormat() U_OVERRIDE;
 
     /**
      * Clone this Format object polymorphically. The caller owns the
@@ -910,7 +903,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return    a polymorphic copy of this DecimalFormat.
      * @stable ICU 2.0
      */
-    virtual Format* clone(void) const;
+    Format* clone(void) const U_OVERRIDE;
 
     /**
      * Return true if the given Format objects are semantically equal.
@@ -920,7 +913,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return         true if the given Format objects are semantically equal.
      * @stable ICU 2.0
      */
-    virtual UBool operator==(const Format& other) const;
+    UBool operator==(const Format& other) const U_OVERRIDE;
 
 
     using NumberFormat::format;
@@ -936,11 +929,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.0
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
-
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format a double or long number using base-10 representation.
      *
@@ -953,10 +944,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format a double or long number using base-10 representation.
@@ -971,10 +961,8 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(double number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a long number using base-10 representation.
@@ -987,10 +975,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.0
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format a long number using base-10 representation.
      *
@@ -1002,10 +989,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format a long number using base-10 representation.
@@ -1020,10 +1006,8 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(int32_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format an int64 number using base-10 representation.
@@ -1036,10 +1020,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 2.8
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
     /**
      * Format an int64 number using base-10 representation.
      *
@@ -1051,10 +1034,9 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode &status) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
+                          UErrorCode& status) const U_OVERRIDE;
+#endif  /* U_HIDE_INTERNAL_API */
 
     /**
      * Format an int64 number using base-10 representation.
@@ -1069,10 +1051,8 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(int64_t number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a decimal number.
@@ -1090,19 +1070,18 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @stable ICU 4.4
      */
-    virtual UnicodeString& format(StringPiece number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
+                          UErrorCode& status) const U_OVERRIDE;
 
+#ifndef U_HIDE_INTERNAL_API
 
     /**
      * Format a decimal number.
-     * The number is a DigitList wrapper onto a floating point decimal number.
+     * The number is a DecimalQuantity wrapper onto a floating point decimal number.
      * The default implementation in NumberFormat converts the decimal number
      * to a double and formats that.
      *
-     * @param number    The number, a DigitList format Decimal Floating Point.
+     * @param number    The number, a DecimalQuantity format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param posIter   On return, can be used to iterate over positions
@@ -1111,14 +1090,16 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPositionIterator* posIter,
-                                  UErrorCode& status) const;
+    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
+                          FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE;
 
     /**
      * Format a decimal number.
-     * @param number    The number
+     * The number is a DecimalQuantity wrapper onto a floating point decimal number.
+     * The default implementation in NumberFormat converts the decimal number
+     * to a double and formats that.
+     *
+     * @param number    The number, a DecimalQuantity format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param pos       On input: an alignment field, if desired.
@@ -1127,73 +1108,34 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(
-            const VisibleDigitsWithExponent &number,
-            UnicodeString& appendTo,
-            FieldPosition& pos,
-            UErrorCode& status) const;
+    UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
+                          FieldPosition& pos, UErrorCode& status) const U_OVERRIDE;
 
-    /**
-     * Format a decimal number.
-     * @param number    The number
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param posIter   On return, can be used to iterate over positions
-     *                  of fields generated by this format call.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
-     */
-    virtual UnicodeString& format(
-            const VisibleDigitsWithExponent &number,
-            UnicodeString& appendTo,
-            FieldPositionIterator* posIter,
-            UErrorCode& status) const;
+#endif // U_HIDE_INTERNAL_API
+
+    using NumberFormat::parse;
 
     /**
-     * Format a decimal number.
-     * The number is a DigitList wrapper onto a floating point decimal number.
-     * The default implementation in NumberFormat converts the decimal number
-     * to a double and formats that.
+     * Parse the given string using this object's choices. The method
+     * does string comparisons to try to find an optimal match.
+     * If no object can be parsed, index is unchanged, and NULL is
+     * returned.  The result is returned as the most parsimonious
+     * type of Formattable that will accomodate all of the
+     * necessary precision.  For example, if the result is exactly 12,
+     * it will be returned as a long.  However, if it is 1.5, it will
+     * be returned as a double.
      *
-     * @param number    The number, a DigitList format Decimal Floating Point.
-     * @param appendTo  Output parameter to receive result.
-     *                  Result is appended to existing contents.
-     * @param pos       On input: an alignment field, if desired.
-     *                  On output: the offsets of the alignment field.
-     * @param status    Output param filled with success/failure status.
-     * @return          Reference to 'appendTo' parameter.
-     * @internal
+     * @param text           The text to be parsed.
+     * @param result         Formattable to be set to the parse result.
+     *                       If parse fails, return contents are undefined.
+     * @param parsePosition  The position to start parsing at on input.
+     *                       On output, moved to after the last successfully
+     *                       parse character. On parse failure, does not change.
+     * @see Formattable
+     * @stable ICU 2.0
      */
-    virtual UnicodeString& format(const DigitList &number,
-                                  UnicodeString& appendTo,
-                                  FieldPosition& pos,
-                                  UErrorCode& status) const;
-
-   using NumberFormat::parse;
-
-   /**
-    * Parse the given string using this object's choices. The method
-    * does string comparisons to try to find an optimal match.
-    * If no object can be parsed, index is unchanged, and NULL is
-    * returned.  The result is returned as the most parsimonious
-    * type of Formattable that will accomodate all of the
-    * necessary precision.  For example, if the result is exactly 12,
-    * it will be returned as a long.  However, if it is 1.5, it will
-    * be returned as a double.
-    *
-    * @param text           The text to be parsed.
-    * @param result         Formattable to be set to the parse result.
-    *                       If parse fails, return contents are undefined.
-    * @param parsePosition  The position to start parsing at on input.
-    *                       On output, moved to after the last successfully
-    *                       parse character. On parse failure, does not change.
-    * @see Formattable
-    * @stable ICU 2.0
-    */
-    virtual void parse(const UnicodeString& text,
-                       Formattable& result,
-                       ParsePosition& parsePosition) const;
+    void parse(const UnicodeString& text, Formattable& result,
+               ParsePosition& parsePosition) const U_OVERRIDE;
 
     /**
      * Parses text from the given string as a currency amount.  Unlike
@@ -1214,8 +1156,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *             the parsed currency; if parse fails, this is NULL.
      * @stable ICU 49
      */
-    virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
-                                          ParsePosition& pos) const;
+    CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
 
     /**
      * Returns the decimal format symbols, which is generally not changed
@@ -1344,12 +1285,29 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      */
     virtual void setNegativeSuffix(const UnicodeString& newValue);
 
+#ifndef U_HIDE_INTERNAL_API
+    /**
+     * Whether to show the plus sign on positive (non-negative) numbers; for example, "+12"
+     * @internal Technical Preview
+     */
+    UBool isSignAlwaysShown() const;
+#endif  /* U_HIDE_INTERNAL_API */
+
+    /**
+     * Set whether to show the plus sign on positive (non-negative) numbers; for example, "+12"
+     * @param value The new setting for whether to show plus sign on positive numbers
+     * @internal Technical Preview
+     */
+    virtual void setSignAlwaysShown(UBool value);
+
     /**
      * Get the multiplier for use in percent, permill, etc.
      * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
      * (For Arabic, use arabic percent symbol).
      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
      *
+     * The number may also be multiplied by a power of ten; see getMultiplierScale().
+     *
      * @return    the multiplier for use in percent, permill, etc.
      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
      * @stable ICU 2.0
@@ -1362,12 +1320,52 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * (For Arabic, use arabic percent symbol).
      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
      *
+     * This method only supports integer multipliers. To multiply by a non-integer, pair this
+     * method with setMultiplierScale().
+     *
      * @param newValue    the new value of the multiplier for use in percent, permill, etc.
      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
      * @stable ICU 2.0
      */
     virtual void setMultiplier(int32_t newValue);
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Gets the power of ten by which number should be multiplied before formatting, which
+     * can be combined with setMultiplier() to multiply by any arbitrary decimal value.
+     *
+     * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale
+     * of -2 corresponds to multiplication by 0.01.
+     *
+     * This method is analogous to UNUM_SCALE in getAttribute.
+     *
+     * @return    the current value of the power-of-ten multiplier.
+     * @draft ICU 62
+     */
+    int32_t getMultiplierScale(void) const;
+#endif  /* U_HIDE_DRAFT_API */
+
+    /**
+     * Sets a power of ten by which number should be multiplied before formatting, which
+     * can be combined with setMultiplier() to multiply by any arbitrary decimal value.
+     *
+     * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale
+     * of -2 corresponds to multiplication by 0.01.
+     *
+     * For example, to multiply numbers by 0.5 before formatting, you can do:
+     *
+     * <pre>
+     * df.setMultiplier(5);
+     * df.setMultiplierScale(-1);
+     * </pre>
+     *
+     * This method is analogous to UNUM_SCALE in setAttribute.
+     *
+     * @param newValue    the new value of the power-of-ten multiplier.
+     * @draft ICU 62
+     */
+    virtual void setMultiplierScale(int32_t newValue);
+
     /**
      * Get the rounding increment.
      * @return A positive rounding increment, or 0.0 if a custom rounding
@@ -1400,7 +1398,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see #setRoundingMode
      * @stable ICU 2.0
      */
-    virtual ERoundingMode getRoundingMode(void) const;
+    virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE;
 
     /**
      * Set the rounding mode.
@@ -1410,7 +1408,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see #getRoundingMode
      * @stable ICU 2.0
      */
-    virtual void setRoundingMode(ERoundingMode roundingMode);
+    virtual void setRoundingMode(ERoundingMode roundingMode) U_OVERRIDE;
 
     /**
      * Get the width to which the output of format() is padded.
@@ -1469,7 +1467,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see #setPadPosition
      * @stable ICU 2.0
      */
-    virtual void setPadCharacter(const UnicodeString &padChar);
+    virtual void setPadCharacter(const UnicodeString& padChar);
 
     /**
      * Get the position at which padding will take place.  This is the location
@@ -1676,7 +1674,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
 
 #endif  /* U_HIDE_INTERNAL_API */
 
-	/* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
+    /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
     /**
      * Sets the minimum grouping digits. Setting to a value less than or
      * equal to 1 turns off minimum grouping digits.
@@ -1717,7 +1715,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
     UBool isDecimalPatternMatchRequired(void) const;
 
     /**
-     * Allows you to set the behavior of the pattern decimal mark.
+     * Allows you to set the parse behavior of the pattern decimal mark.
      *
      * if TRUE, the input must have a decimal mark if one was specified in the pattern. When
      * FALSE the decimal mark may be omitted from the input.
@@ -1727,6 +1725,60 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      */
     virtual void setDecimalPatternMatchRequired(UBool newValue);
 
+    /**
+     * {@icu} Returns whether to ignore exponents when parsing.
+     *
+     * @see #setParseNoExponent
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isParseNoExponent() const;
+
+    /**
+     * {@icu} Specifies whether to stop parsing when an exponent separator is encountered. For
+     * example, parses "123E4" to 123 (with parse position 3) instead of 1230000 (with parse position
+     * 5).
+     *
+     * @param value true to prevent exponents from being parsed; false to allow them to be parsed.
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setParseNoExponent(UBool value);
+
+    /**
+     * {@icu} Returns whether parsing is sensitive to case (lowercase/uppercase).
+     *
+     * @see #setParseCaseSensitive
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isParseCaseSensitive() const;
+
+    /**
+     * {@icu} Whether to pay attention to case when parsing; default is to ignore case (perform
+     * case-folding). For example, "A" == "a" in case-insensitive but not case-sensitive mode.
+     *
+     * Currency symbols are never case-folded. For example, "us$1.00" will not parse in case-insensitive
+     * mode, even though "US$1.00" parses.
+     *
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setParseCaseSensitive(UBool value);
+
+    /**
+     * {@icu} Returns whether truncation of high-order integer digits should result in an error.
+     * By default, setMaximumIntegerDigits truncates high-order digits silently.
+     *
+     * @see setFormatFailIfMoreThanMaxDigits
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual UBool isFormatFailIfMoreThanMaxDigits() const;
+
+    /**
+     * {@icu} Sets whether truncation of high-order integer digits should result in an error.
+     * By default, setMaximumIntegerDigits truncates high-order digits silently.
+     *
+     * @internal This API is a technical preview. It may change in an upcoming release.
+     */
+    virtual void setFormatFailIfMoreThanMaxDigits(UBool value);
+
 
     /**
      * Synthesizes a pattern string that represents the current state
@@ -1781,9 +1833,8 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                   set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyPattern(const UnicodeString& pattern,
-                             UParseError& parseError,
-                             UErrorCode& status);
+    virtual void applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status);
+
     /**
      * Sets the pattern.
      * @param pattern   The pattern to be applied.
@@ -1792,8 +1843,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyPattern(const UnicodeString& pattern,
-                             UErrorCode& status);
+    virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status);
 
     /**
      * Apply the given pattern to this Format object.  The pattern
@@ -1825,8 +1875,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyLocalizedPattern(const UnicodeString& pattern,
-                                       UParseError& parseError,
+    virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError,
                                        UErrorCode& status);
 
     /**
@@ -1838,8 +1887,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                  set to a failure result.
      * @stable ICU 2.0
      */
-    virtual void applyLocalizedPattern(const UnicodeString& pattern,
-                                       UErrorCode& status);
+    virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status);
 
 
     /**
@@ -1851,7 +1899,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see NumberFormat#setMaximumIntegerDigits
      * @stable ICU 2.0
      */
-    virtual void setMaximumIntegerDigits(int32_t newValue);
+    void setMaximumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the minimum number of digits allowed in the integer portion of a
@@ -1862,7 +1910,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see NumberFormat#setMinimumIntegerDigits
      * @stable ICU 2.0
      */
-    virtual void setMinimumIntegerDigits(int32_t newValue);
+    void setMinimumIntegerDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the maximum number of digits allowed in the fraction portion of a
@@ -1873,7 +1921,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see NumberFormat#setMaximumFractionDigits
      * @stable ICU 2.0
      */
-    virtual void setMaximumFractionDigits(int32_t newValue);
+    void setMaximumFractionDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Sets the minimum number of digits allowed in the fraction portion of a
@@ -1884,7 +1932,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @see NumberFormat#setMinimumFractionDigits
      * @stable ICU 2.0
      */
-    virtual void setMinimumFractionDigits(int32_t newValue);
+    void setMinimumFractionDigits(int32_t newValue) U_OVERRIDE;
 
     /**
      * Returns the minimum number of significant digits that will be
@@ -1947,7 +1995,6 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      */
     void setSignificantDigitsUsed(UBool useSignificantDigits);
 
- public:
     /**
      * Sets the currency used to display currency
      * amounts.  This takes effect immediately, if this format is a
@@ -1960,7 +2007,7 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      * @param ec input-output error code
      * @stable ICU 3.0
      */
-    virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
+    void setCurrency(const char16_t* theCurrency, UErrorCode& ec) U_OVERRIDE;
 
     /**
      * Sets the currency used to display currency amounts.  See
@@ -1984,78 +2031,53 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      */
     UCurrencyUsage getCurrencyUsage() const;
 
-
-#ifndef U_HIDE_DEPRECATED_API
-    /**
-     * The resource tags we use to retrieve decimal format data from
-     * locale resource bundles.
-     * @deprecated ICU 3.4. This string has no public purpose. Please don't use it.
-     */
-    static const char fgNumberPatterns[];
-#endif  // U_HIDE_DEPRECATED_API
-
 #ifndef U_HIDE_INTERNAL_API
-    /**
-     *  Get a FixedDecimal corresponding to a double as it would be
-     *  formatted by this DecimalFormat.
-     *  Internal, not intended for public use.
-     *  @internal
-     */
-     FixedDecimal getFixedDecimal(double number, UErrorCode &status) const;
-
-    /**
-     *  Get a FixedDecimal corresponding to a formattable as it would be
-     *  formatted by this DecimalFormat.
-     *  Internal, not intended for public use.
-     *  @internal
-     */
-     FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const;
 
     /**
-     *  Get a FixedDecimal corresponding to a DigitList as it would be
-     *  formatted by this DecimalFormat. Note: the DigitList may be modified.
+     *  Format a number and save it into the given DecimalQuantity.
      *  Internal, not intended for public use.
      *  @internal
      */
-     FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const;
+    void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output,
+                                 UErrorCode& status) const;
 
     /**
-     *  Get a VisibleDigitsWithExponent corresponding to a double
-     *  as it would be formatted by this DecimalFormat.
+     *  Get a DecimalQuantity corresponding to a formattable as it would be
+     *  formatted by this DecimalFormat.
      *  Internal, not intended for public use.
      *  @internal
      */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             double number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
+    void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output,
+                                 UErrorCode& status) const;
 
-    /**
-     *  Get a VisibleDigitsWithExponent corresponding to a formattable
-     *  as it would be formatted by this DecimalFormat.
-     *  Internal, not intended for public use.
-     *  @internal
-     */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             const Formattable &number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
+#endif
 
+#ifndef U_HIDE_DRAFT_API
     /**
-     *  Get a VisibleDigitsWithExponent corresponding to a DigitList
-     *  as it would be formatted by this DecimalFormat.
-     *  Note: the DigitList may be modified.
-     *  Internal, not intended for public use.
-     *  @internal
+     * Converts this DecimalFormat to a NumberFormatter.  Starting in ICU 60,
+     * NumberFormatter is the recommended way to format numbers.
+     *
+     * NOTE: The returned LocalizedNumberFormatter is owned by this DecimalFormat.
+     * If a non-const method is called on the DecimalFormat, or if the DecimalFormat
+     * is deleted, the object becomes invalid. If you plan to keep the return value
+     * beyond the lifetime of the DecimalFormat, copy it to a local variable:
+     *
+     * <pre>
+     * LocalizedNumberFormatter f = df->toNumberFormatter();
+     * </pre>
+     *
+     * It is, however, safe to use the return value for chaining:
+     *
+     * <pre>
+     * FormattedNumber result = df->toNumberFormatter().formatDouble(123, status);
+     * </pre>
+     *
+     * @param output The variable into which to store the LocalizedNumberFormatter.
+     * @return The output variable, for chaining.
+     * @draft ICU 62
      */
-     VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
-             DigitList &number,
-             VisibleDigitsWithExponent &digits,
-             UErrorCode &status) const;
-
-#endif  /* U_HIDE_INTERNAL_API */
-
-public:
+    const number::LocalizedNumberFormatter& toNumberFormatter() const;
+#endif  /* U_HIDE_DRAFT_API */
 
     /**
      * Return the class ID for this class.  This is useful only for
@@ -2081,217 +2103,57 @@ class U_I18N_API DecimalFormat: public NumberFormat {
      *                  other classes have different class IDs.
      * @stable ICU 2.0
      */
-    virtual UClassID getDynamicClassID(void) const;
-
-private:
-
-    DecimalFormat(); // default constructor not implemented
-
-    /**
-     *   Initialize all fields of a new DecimalFormatter to a safe default value.
-     *      Common code for use by constructors.
-     */
-    void init();
-
-    /**
-     * Do real work of constructing a new DecimalFormat.
-     */
-    void construct(UErrorCode&              status,
-                   UParseError&             parseErr,
-                   const UnicodeString*     pattern = 0,
-                   DecimalFormatSymbols*    symbolsToAdopt = 0
-                   );
-
-    void handleCurrencySignInPattern(UErrorCode& status);
-
-    void parse(const UnicodeString& text,
-               Formattable& result,
-               ParsePosition& pos,
-               char16_t* currency) const;
-
-    enum {
-        fgStatusInfinite,
-        fgStatusLength      // Leave last in list.
-    } StatusFlags;
-
-    UBool subparse(const UnicodeString& text,
-                   const UnicodeString* negPrefix,
-                   const UnicodeString* negSuffix,
-                   const UnicodeString* posPrefix,
-                   const UnicodeString* posSuffix,
-                   UBool complexCurrencyParsing,
-                   int8_t type,
-                   ParsePosition& parsePosition,
-                   DigitList& digits, UBool* status,
-                   char16_t* currency) const;
-
-    // Mixed style parsing for currency.
-    // It parses against the current currency pattern
-    // using complex affix comparison
-    // parses against the currency plural patterns using complex affix comparison,
-    // and parses against the current pattern using simple affix comparison.
-    UBool parseForCurrency(const UnicodeString& text,
-                           ParsePosition& parsePosition,
-                           DigitList& digits,
-                           UBool* status,
-                           char16_t* currency) const;
-
-    int32_t skipPadding(const UnicodeString& text, int32_t position) const;
-
-    int32_t compareAffix(const UnicodeString& input,
-                         int32_t pos,
-                         UBool isNegative,
-                         UBool isPrefix,
-                         const UnicodeString* affixPat,
-                         UBool complexCurrencyParsing,
-                         int8_t type,
-                         char16_t* currency) const;
-
-    static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
-
-    UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const;
-
-    int32_t compareSimpleAffix(const UnicodeString& affix,
-                                      const UnicodeString& input,
-                                      int32_t pos,
-                                      UBool lenient) const;
-
-    static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos);
-
-    static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos);
-
-    int32_t compareComplexAffix(const UnicodeString& affixPat,
-                                const UnicodeString& input,
-                                int32_t pos,
-                                int8_t type,
-                                char16_t* currency) const;
-
-    static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
+    UClassID getDynamicClassID(void) const U_OVERRIDE;
 
-    static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str);
+  private:
 
-    static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
-                             UnicodeSet *sset, UChar32 schar);
+    /** Rebuilds the formatter object from the property bag. */
+    void touch(UErrorCode& status);
 
-    static UBool matchDecimal(UChar32 symbolChar,
-                            UBool sawDecimal,  UChar32 sawDecimalChar,
-                             const UnicodeSet *sset, UChar32 schar);
-
-    static UBool matchGrouping(UChar32 groupingChar,
-                            UBool sawGrouping, UChar32 sawGroupingChar,
-                             const UnicodeSet *sset,
-                             UChar32 decimalChar, const UnicodeSet *decimalSet,
-                             UChar32 schar);
-
-    // set up currency affix patterns for mix parsing.
-    // The patterns saved here are the affix patterns of default currency
-    // pattern and the unique affix patterns of the plural currency patterns.
-    // Those patterns are used by parseForCurrency().
-    void setupCurrencyAffixPatterns(UErrorCode& status);
-
-    // get the currency rounding with respect to currency usage
-    double getCurrencyRounding(const char16_t* currency,
-                               UErrorCode* ec) const;
-
-    // get the currency fraction with respect to currency usage
-    int getCurrencyFractionDigits(const char16_t* currency,
-                                  UErrorCode* ec) const;
-
-    // hashtable operations
-    Hashtable* initHashForAffixPattern(UErrorCode& status);
-
-    void deleteHashForAffixPattern();
-
-    void copyHashForAffixPattern(const Hashtable* source,
-                                 Hashtable* target, UErrorCode& status);
-
-    DecimalFormatImpl *fImpl;
+    /** Rebuilds the formatter object, hiding the error code. */
+    void touchNoError();
 
     /**
-     * Constants.
+     * Updates the property bag with settings from the given pattern.
+     *
+     * @param pattern The pattern string to parse.
+     * @param ignoreRounding Whether to leave out rounding information (minFrac, maxFrac, and rounding
+     *     increment) when parsing the pattern. This may be desirable if a custom rounding mode, such
+     *     as CurrencyUsage, is to be used instead. One of {@link
+     *     PatternStringParser#IGNORE_ROUNDING_ALWAYS}, {@link PatternStringParser#IGNORE_ROUNDING_IF_CURRENCY},
+     *     or {@link PatternStringParser#IGNORE_ROUNDING_NEVER}.
+     * @see PatternAndPropertyUtils#parseToExistingProperties
      */
+    void setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding,
+                                  UErrorCode& status);
 
+    const numparse::impl::NumberParserImpl* getParser(UErrorCode& status) const;
 
-    EnumSet<UNumberFormatAttribute,
-            UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
-            UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
-                            fBoolFlags;
+    const numparse::impl::NumberParserImpl* getCurrencyParser(UErrorCode& status) const;
 
+    static void fieldPositionHelper(const number::FormattedNumber& formatted, FieldPosition& fieldPosition,
+                                    int32_t offset, UErrorCode& status);
 
-    // style is only valid when decimal formatter is constructed by
-    // DecimalFormat(pattern, decimalFormatSymbol, style)
-    int fStyle;
+    static void fieldPositionIteratorHelper(const number::FormattedNumber& formatted,
+                                            FieldPositionIterator* fpi, int32_t offset, UErrorCode& status);
 
+    void setupFastFormat();
 
-    // Affix pattern set for currency.
-    // It is a set of AffixPatternsForCurrency,
-    // each element of the set saves the negative prefix pattern,
-    // negative suffix pattern, positive prefix pattern,
-    // and positive suffix  pattern of a pattern.
-    // It is used for currency mixed style parsing.
-    // It is actually is a set.
-    // The set contains the default currency pattern from the locale,
-    // and the currency plural patterns.
-    // Since it is a set, it does not contain duplicated items.
-    // For example, if 2 currency plural patterns are the same, only one pattern
-    // is included in the set. When parsing, we do not check whether the plural
-    // count match or not.
-    Hashtable* fAffixPatternsForCurrency;
+    bool fastFormatDouble(double input, UnicodeString& output) const;
 
-    // Information needed for DecimalFormat to format/parse currency plural.
-    CurrencyPluralInfo* fCurrencyPluralInfo;
+    bool fastFormatInt64(int64_t input, UnicodeString& output) const;
 
-#if UCONFIG_HAVE_PARSEALLINPUT
-    UNumberFormatAttributeValue fParseAllInput;
-#endif
+    void doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const;
 
-    // Decimal Format Static Sets singleton.
-    const DecimalFormatStaticSets *fStaticSets;
+    //=====================================================================================//
+    //                                   INSTANCE FIELDS                                   //
+    //=====================================================================================//
 
-protected:
+    // Only one instance field: keep all fields inside of an implementation class defined in number_mapper.h
+    number::impl::DecimalFormatFields* fields;
 
-#ifndef U_HIDE_INTERNAL_API
-    /**
-     * Rounds a value according to the rules of this object.
-     * @internal
-     */
-    DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const;
-#endif  /* U_HIDE_INTERNAL_API */
-
-    /**
-     * Returns the currency in effect for this formatter.  Subclasses
-     * should override this method as needed.  Unlike getCurrency(),
-     * this method should never return "".
-     * @result output parameter for null-terminated result, which must
-     * have a capacity of at least 4
-     * @internal
-     */
-    virtual void getEffectiveCurrency(char16_t* result, UErrorCode& ec) const;
-
-  /** number of integer digits
-   * @stable ICU 2.4
-   */
-    static const int32_t  kDoubleIntegerDigits;
-  /** number of fraction digits
-   * @stable ICU 2.4
-   */
-    static const int32_t  kDoubleFractionDigits;
-
-    /**
-     * When someone turns on scientific mode, we assume that more than this
-     * number of digits is due to flipping from some other mode that didn't
-     * restrict the maximum, and so we force 1 integer digit.  We don't bother
-     * to track and see if someone is using exponential notation with more than
-     * this number, it wouldn't make sense anyway, and this is just to make sure
-     * that someone turning on scientific mode with default settings doesn't
-     * end up with lots of zeroes.
-     * @stable ICU 2.8
-     */
-    static const int32_t  kMaxScientificIntegerDigits;
+    // Allow child class CompactDecimalFormat to access fProperties:
+    friend class CompactDecimalFormat;
 
 };
 
diff --git a/deps/icu-small/source/i18n/unicode/fmtable.h b/deps/icu-small/source/i18n/unicode/fmtable.h
index 766a71969deadc..2359b61d46186e 100644
--- a/deps/icu-small/source/i18n/unicode/fmtable.h
+++ b/deps/icu-small/source/i18n/unicode/fmtable.h
@@ -33,17 +33,11 @@
 U_NAMESPACE_BEGIN
 
 class CharString;
-class DigitList;
-
-/**
- * \def UNUM_INTERNAL_STACKARRAY_SIZE
- * @internal
- */
-#if U_PLATFORM == U_PF_OS400
-#define UNUM_INTERNAL_STACKARRAY_SIZE 144
-#else
-#define UNUM_INTERNAL_STACKARRAY_SIZE 128
-#endif
+namespace number {
+namespace impl {
+class DecimalQuantity;
+}
+}
 
 /**
  * Formattable objects can be passed to the Format class or
@@ -649,24 +643,25 @@ class U_I18N_API Formattable : public UObject {
      * Internal function, do not use.
      * TODO:  figure out how to make this be non-public.
      *        NumberFormat::format(Formattable, ...
-     *        needs to get at the DigitList, if it exists, for
+     *        needs to get at the DecimalQuantity, if it exists, for
      *        big decimal formatting.
      *  @internal
      */
-    DigitList *getDigitList() const { return fDecimalNum;}
+    number::impl::DecimalQuantity *getDecimalQuantity() const { return fDecimalQuantity;}
 
     /**
-     *  @internal
+     * Export the value of this Formattable to a DecimalQuantity.
+     * @internal
      */
-    DigitList *getInternalDigitList();
+    void populateDecimalQuantity(number::impl::DecimalQuantity& output, UErrorCode& status) const;
 
     /**
-     *  Adopt, and set value from, a DigitList
+     *  Adopt, and set value from, a DecimalQuantity
      *     Internal Function, do not use.
-     *  @param dl the Digit List to be adopted
+     *  @param dl the DecimalQuantity to be adopted
      *  @internal
      */
-    void adoptDigitList(DigitList *dl);
+    void adoptDecimalQuantity(number::impl::DecimalQuantity *dq);
 
     /**
      * Internal function to return the CharString pointer.
@@ -706,9 +701,7 @@ class U_I18N_API Formattable : public UObject {
 
     CharString           *fDecimalStr;
 
-    DigitList            *fDecimalNum;
-
-    char                fStackData[UNUM_INTERNAL_STACKARRAY_SIZE]; // must be big enough for DigitList
+    number::impl::DecimalQuantity *fDecimalQuantity;
 
     Type                fType;
     UnicodeString       fBogus; // Bogus string when it's needed.
diff --git a/deps/icu-small/source/i18n/unicode/fpositer.h b/deps/icu-small/source/i18n/unicode/fpositer.h
index 8e9d69c547f849..81091f0ffad6b6 100644
--- a/deps/icu-small/source/i18n/unicode/fpositer.h
+++ b/deps/icu-small/source/i18n/unicode/fpositer.h
@@ -47,13 +47,6 @@ U_NAMESPACE_BEGIN
 
 class UVector32;
 
-// Forward declaration for number formatting:
-namespace number {
-namespace impl {
-class NumberStringBuilder;
-}
-}
-
 /**
  * FieldPositionIterator returns the field ids and their start/limit positions generated
  * by a call to Format::format.  See Format, NumberFormat, DecimalFormat.
@@ -114,7 +107,6 @@ class U_I18N_API FieldPositionIterator : public UObject {
     void setData(UVector32 *adopt, UErrorCode& status);
 
     friend class FieldPositionIteratorHandler;
-    friend class number::impl::NumberStringBuilder;
 
     UVector32 *data;
     int32_t pos;
diff --git a/deps/icu-small/source/i18n/unicode/measunit.h b/deps/icu-small/source/i18n/unicode/measunit.h
index f7ddb4e20c559f..f552253544f890 100644
--- a/deps/icu-small/source/i18n/unicode/measunit.h
+++ b/deps/icu-small/source/i18n/unicode/measunit.h
@@ -400,14 +400,6 @@ class U_I18N_API MeasureUnit: public UObject {
      */
     static MeasureUnit *createMilePerGallonImperial(UErrorCode &status);
 
-    /*
-     * The following were draft ICU 58, but have been withdrawn:
-     * static MeasureUnit *createEast(UErrorCode &status);
-     * static MeasureUnit *createNorth(UErrorCode &status);
-     * static MeasureUnit *createSouth(UErrorCode &status);
-     * static MeasureUnit *createWest(UErrorCode &status);
-     */
-
     /**
      * Returns unit of digital: bit.
      * Caller owns returned value and must free it.
diff --git a/deps/icu-small/source/i18n/unicode/nounit.h b/deps/icu-small/source/i18n/unicode/nounit.h
index 290e77e8806040..288f268d66d658 100644
--- a/deps/icu-small/source/i18n/unicode/nounit.h
+++ b/deps/icu-small/source/i18n/unicode/nounit.h
@@ -61,6 +61,12 @@ class U_I18N_API NoUnit: public MeasureUnit {
      */
     NoUnit(const NoUnit& other);
 
+    /**
+     * Destructor.
+     * @draft ICU 60
+     */
+    virtual ~NoUnit();
+
     /**
      * Return a polymorphic clone of this object.  The result will
      * have the same class as returned by getDynamicClassID().
@@ -86,12 +92,6 @@ class U_I18N_API NoUnit: public MeasureUnit {
      */
     static UClassID U_EXPORT2 getStaticClassID();
 
-    /**
-     * Destructor.
-     * @draft ICU 60
-     */
-    virtual ~NoUnit();
-
 private:
     /**
      * Constructor
diff --git a/deps/icu-small/source/i18n/unicode/numberformatter.h b/deps/icu-small/source/i18n/unicode/numberformatter.h
index 3fbb33cceeabf7..3ab08319f73bc7 100644
--- a/deps/icu-small/source/i18n/unicode/numberformatter.h
+++ b/deps/icu-small/source/i18n/unicode/numberformatter.h
@@ -17,6 +17,8 @@
 #include "unicode/plurrule.h"
 #include "unicode/ucurr.h"
 #include "unicode/unum.h"
+#include "unicode/unumberformatter.h"
+#include "unicode/uobject.h"
 
 #ifndef U_HIDE_DRAFT_API
 
@@ -31,11 +33,11 @@
  * // Most basic usage:
  * NumberFormatter::withLocale(...).format(123).toString();  // 1,234 in en-US
  *
- * // Custom notation, unit, and rounding strategy:
+ * // Custom notation, unit, and rounding precision:
  * NumberFormatter::with()
  *     .notation(Notation::compactShort())
  *     .unit(CurrencyUnit("EUR", status))
- *     .rounding(Rounder::maxDigits(2))
+ *     .precision(Precision::maxDigits(2))
  *     .locale(...)
  *     .format(1234)
  *     .toString();  // €1.2K in en-US
@@ -43,7 +45,7 @@
  * // Create a formatter in a singleton for use later:
  * static const LocalizedNumberFormatter formatter = NumberFormatter::withLocale(...)
  *     .unit(NoUnit::percent())
- *     .rounding(Rounder::fixedFraction(3));
+ *     .precision(Precision::fixedFraction(3));
  * formatter.format(5.9831).toString();  // 5.983% in en-US
  *
  * // Create a "template" in a singleton but without setting a locale until the call site:
@@ -63,7 +65,7 @@
  *
  * <pre>
  * UnlocalizedNumberFormatter formatter = UnlocalizedNumberFormatter::with().notation(Notation::scientific());
- * formatter.rounding(Rounder.maxFraction(2)); // does nothing!
+ * formatter.precision(Precision.maxFraction(2)); // does nothing!
  * formatter.locale(Locale.getEnglish()).format(9.8765).toString(); // prints "9.8765E0", not "9.88E0"
  * </pre>
  *
@@ -74,321 +76,23 @@
  * @author Shane Carr
  */
 
-/**
- * An enum declaring how to render units, including currencies. Example outputs when formatting 123 USD and 123
- * meters in <em>en-CA</em>:
- *
- * <p>
- * <ul>
- * <li>NARROW*: "$123.00" and "123 m"
- * <li>SHORT: "US$ 123.00" and "123 m"
- * <li>FULL_NAME: "123.00 US dollars" and "123 meters"
- * <li>ISO_CODE: "USD 123.00" and undefined behavior
- * <li>HIDDEN: "123.00" and "123"
- * </ul>
- *
- * <p>
- * This enum is similar to {@link com.ibm.icu.text.MeasureFormat.FormatWidth}.
- *
- * @draft ICU 60
- */
-typedef enum UNumberUnitWidth {
-    /**
-     * Print an abbreviated version of the unit name. Similar to SHORT, but always use the shortest available
-     * abbreviation or symbol. This option can be used when the context hints at the identity of the unit. For more
-     * information on the difference between NARROW and SHORT, see SHORT.
-     *
-     * <p>
-     * In CLDR, this option corresponds to the "Narrow" format for measure units and the "¤¤¤¤¤" placeholder for
-     * currencies.
-     *
-     * @draft ICU 60
-     */
-            UNUM_UNIT_WIDTH_NARROW,
-
-    /**
-     * Print an abbreviated version of the unit name. Similar to NARROW, but use a slightly wider abbreviation or
-     * symbol when there may be ambiguity. This is the default behavior.
-     *
-     * <p>
-     * For example, in <em>es-US</em>, the SHORT form for Fahrenheit is "{0} °F", but the NARROW form is "{0}°",
-     * since Fahrenheit is the customary unit for temperature in that locale.
-     *
-     * <p>
-     * In CLDR, this option corresponds to the "Short" format for measure units and the "¤" placeholder for
-     * currencies.
-     *
-     * @draft ICU 60
-     */
-            UNUM_UNIT_WIDTH_SHORT,
-
-    /**
-     * Print the full name of the unit, without any abbreviations.
-     *
-     * <p>
-     * In CLDR, this option corresponds to the default format for measure units and the "¤¤¤" placeholder for
-     * currencies.
-     *
-     * @draft ICU 60
-     */
-            UNUM_UNIT_WIDTH_FULL_NAME,
-
-    /**
-     * Use the three-digit ISO XXX code in place of the symbol for displaying currencies. The behavior of this
-     * option is currently undefined for use with measure units.
-     *
-     * <p>
-     * In CLDR, this option corresponds to the "¤¤" placeholder for currencies.
-     *
-     * @draft ICU 60
-     */
-            UNUM_UNIT_WIDTH_ISO_CODE,
-
-    /**
-     * Format the number according to the specified unit, but do not display the unit. For currencies, apply
-     * monetary symbols and formats as with SHORT, but omit the currency symbol. For measure units, the behavior is
-     * equivalent to not specifying the unit at all.
-     *
-     * @draft ICU 60
-     */
-            UNUM_UNIT_WIDTH_HIDDEN
-
-#ifndef U_HIDE_INTERNAL_API
-    ,
-    /**
-     * One more than the highest UNumberUnitWidth value.
-     *
-     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
-     */
-            UNUM_UNIT_WIDTH_COUNT
-#endif  // U_HIDE_INTERNAL_API
-} UNumberUnitWidth;
-
-/**
- * An enum declaring the strategy for when and how to display grouping separators (i.e., the
- * separator, often a comma or period, after every 2-3 powers of ten). The choices are several
- * pre-built strategies for different use cases that employ locale data whenever possible. Example
- * outputs for 1234 and 1234567 in <em>en-IN</em>:
- *
- * <ul>
- * <li>OFF: 1234 and 12345
- * <li>MIN2: 1234 and 12,34,567
- * <li>AUTO: 1,234 and 12,34,567
- * <li>ON_ALIGNED: 1,234 and 12,34,567
- * <li>THOUSANDS: 1,234 and 1,234,567
- * </ul>
- *
- * <p>
- * The default is AUTO, which displays grouping separators unless the locale data says that grouping
- * is not customary. To force grouping for all numbers greater than 1000 consistently across locales,
- * use ON_ALIGNED. On the other hand, to display grouping less frequently than the default, use MIN2
- * or OFF. See the docs of each option for details.
- *
- * <p>
- * Note: This enum specifies the strategy for grouping sizes. To set which character to use as the
- * grouping separator, use the "symbols" setter.
- *
- * @draft ICU 61
- */
-typedef enum UGroupingStrategy {
-    /**
-     * Do not display grouping separators in any locale.
-     *
-     * @draft ICU 61
-     */
-    UNUM_GROUPING_OFF,
-
-    /**
-     * Display grouping using locale defaults, except do not show grouping on values smaller than
-     * 10000 (such that there is a <em>minimum of two digits</em> before the first separator).
-     *
-     * <p>
-     * Note that locales may restrict grouping separators to be displayed only on 1 million or
-     * greater (for example, ee and hu) or disable grouping altogether (for example, bg currency).
-     *
-     * <p>
-     * Locale data is used to determine whether to separate larger numbers into groups of 2
-     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
-     *
-     * @draft ICU 61
-     */
-    UNUM_GROUPING_MIN2,
-
-    /**
-     * Display grouping using the default strategy for all locales. This is the default behavior.
-     *
-     * <p>
-     * Note that locales may restrict grouping separators to be displayed only on 1 million or
-     * greater (for example, ee and hu) or disable grouping altogether (for example, bg currency).
-     *
-     * <p>
-     * Locale data is used to determine whether to separate larger numbers into groups of 2
-     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
-     *
-     * @draft ICU 61
-     */
-    UNUM_GROUPING_AUTO,
-
-    /**
-     * Always display the grouping separator on values of at least 1000.
-     *
-     * <p>
-     * This option ignores the locale data that restricts or disables grouping, described in MIN2 and
-     * AUTO. This option may be useful to normalize the alignment of numbers, such as in a
-     * spreadsheet.
-     *
-     * <p>
-     * Locale data is used to determine whether to separate larger numbers into groups of 2
-     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
-     *
-     * @draft ICU 61
-     */
-    UNUM_GROUPING_ON_ALIGNED,
-
-    /**
-     * Use the Western defaults: groups of 3 and enabled for all numbers 1000 or greater. Do not use
-     * locale data for determining the grouping strategy.
-     *
-     * @draft ICU 61
-     */
-    UNUM_GROUPING_THOUSANDS
-
-} UGroupingStrategy;
-
-/**
- * An enum declaring how to denote positive and negative numbers. Example outputs when formatting
- * 123, 0, and -123 in <em>en-US</em>:
- *
- * <ul>
- * <li>AUTO: "123", "0", and "-123"
- * <li>ALWAYS: "+123", "+0", and "-123"
- * <li>NEVER: "123", "0", and "123"
- * <li>ACCOUNTING: "$123", "$0", and "($123)"
- * <li>ACCOUNTING_ALWAYS: "+$123", "+$0", and "($123)"
- * <li>EXCEPT_ZERO: "+123", "0", and "-123"
- * <li>ACCOUNTING_EXCEPT_ZERO: "+$123", "$0", and "($123)"
- * </ul>
- *
- * <p>
- * The exact format, including the position and the code point of the sign, differ by locale.
- *
- * @draft ICU 60
- */
-typedef enum UNumberSignDisplay {
-    /**
-     * Show the minus sign on negative numbers, and do not show the sign on positive numbers. This is the default
-     * behavior.
-     *
-     * @draft ICU 60
-     */
-    UNUM_SIGN_AUTO,
-
-    /**
-     * Show the minus sign on negative numbers and the plus sign on positive numbers, including zero.
-     * To hide the sign on zero, see {@link UNUM_SIGN_EXCEPT_ZERO}.
-     *
-     * @draft ICU 60
-     */
-    UNUM_SIGN_ALWAYS,
-
-    /**
-     * Do not show the sign on positive or negative numbers.
-     *
-     * @draft ICU 60
-     */
-    UNUM_SIGN_NEVER,
-
-    /**
-     * Use the locale-dependent accounting format on negative numbers, and do not show the sign on positive numbers.
-     *
-     * <p>
-     * The accounting format is defined in CLDR and varies by locale; in many Western locales, the format is a pair
-     * of parentheses around the number.
-     *
-     * <p>
-     * Note: Since CLDR defines the accounting format in the monetary context only, this option falls back to the
-     * AUTO sign display strategy when formatting without a currency unit. This limitation may be lifted in the
-     * future.
-     *
-     * @draft ICU 60
-     */
-    UNUM_SIGN_ACCOUNTING,
-
-    /**
-     * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
-     * positive numbers, including zero. For more information on the accounting format, see the
-     * ACCOUNTING sign display strategy. To hide the sign on zero, see
-     * {@link UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO}.
-     *
-     * @draft ICU 60
-     */
-    UNUM_SIGN_ACCOUNTING_ALWAYS,
-
-    /**
-     * Show the minus sign on negative numbers and the plus sign on positive numbers. Do not show a
-     * sign on zero.
-     *
-     * @draft ICU 61
-     */
-    UNUM_SIGN_EXCEPT_ZERO,
-
-    /**
-     * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
-     * positive numbers. Do not show a sign on zero. For more information on the accounting format,
-     * see the ACCOUNTING sign display strategy.
-     *
-     * @draft ICU 61
-     */
-    UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO
+U_NAMESPACE_BEGIN
 
-#ifndef U_HIDE_INTERNAL_API
-    ,
-    /**
-     * One more than the highest UNumberSignDisplay value.
-     *
-     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
-     */
-    UNUM_SIGN_COUNT
-#endif  // U_HIDE_INTERNAL_API
-} UNumberSignDisplay;
+// Forward declarations:
+class IFixedDecimal;
+class FieldPositionIteratorHandler;
 
-/**
- * An enum declaring how to render the decimal separator.
- *
- * <p>
- * <ul>
- * <li>UNUM_DECIMAL_SEPARATOR_AUTO: "1", "1.1"
- * <li>UNUM_DECIMAL_SEPARATOR_ALWAYS: "1.", "1.1"
- * </ul>
- */
-typedef enum UNumberDecimalSeparatorDisplay {
-    /**
-     * Show the decimal separator when there are one or more digits to display after the separator, and do not show
-     * it otherwise. This is the default behavior.
-     *
-     * @draft ICU 60
-     */
-            UNUM_DECIMAL_SEPARATOR_AUTO,
+namespace numparse {
+namespace impl {
 
-    /**
-     * Always show the decimal separator, even if there are no digits to display after the separator.
-     *
-     * @draft ICU 60
-     */
-            UNUM_DECIMAL_SEPARATOR_ALWAYS
+// Forward declarations:
+class NumberParserImpl;
+class MultiplierParseHandler;
 
-#ifndef U_HIDE_INTERNAL_API
-    ,
-    /**
-     * One more than the highest UNumberDecimalSeparatorDisplay value.
-     *
-     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
-     */
-            UNUM_DECIMAL_SEPARATOR_COUNT
-#endif  // U_HIDE_INTERNAL_API
-} UNumberDecimalMarkDisplay;
+}
+}
 
-U_NAMESPACE_BEGIN namespace number {  // icu::number
+namespace number {  // icu::number
 
 // Forward declarations:
 class UnlocalizedNumberFormatter;
@@ -396,15 +100,14 @@ class LocalizedNumberFormatter;
 class FormattedNumber;
 class Notation;
 class ScientificNotation;
-class Rounder;
-class FractionRounder;
-class CurrencyRounder;
-class IncrementRounder;
+class Precision;
+class FractionPrecision;
+class CurrencyPrecision;
+class IncrementPrecision;
 class IntegerWidth;
 
 namespace impl {
 
-#ifndef U_HIDE_INTERNAL_API
 /**
  * Datatype for minimum/maximum fraction digits. Must be able to hold kMaxIntFracSig.
  *
@@ -419,24 +122,28 @@ typedef int16_t digits_t;
  * @internal
  */
 static constexpr int32_t DEFAULT_THRESHOLD = 3;
-#endif  // U_HIDE_INTERNAL_API
 
 // Forward declarations:
 class Padder;
 struct MacroProps;
 struct MicroProps;
 class DecimalQuantity;
-struct NumberFormatterResults;
+struct UFormattedNumberData;
 class NumberFormatterImpl;
 struct ParsedPatternInfo;
 class ScientificModifier;
 class MultiplierProducer;
-class MutablePatternModifier;
-class LongNameHandler;
+class RoundingImpl;
 class ScientificHandler;
-class CompactHandler;
 class Modifier;
 class NumberStringBuilder;
+class AffixPatternProvider;
+class NumberPropertyMapper;
+struct DecimalFormatProperties;
+class MultiplierFormatHandler;
+class CurrencySymbols;
+class GeneratorHelpers;
+class DecNum;
 
 } // namespace impl
 
@@ -530,13 +237,13 @@ class U_I18N_API Notation : public UMemory {
      * </pre>
      *
      * <p>
-     * When compact notation is specified without an explicit rounding strategy, numbers are rounded off to the closest
+     * When compact notation is specified without an explicit rounding precision, numbers are rounded off to the closest
      * integer after scaling the number by the corresponding power of 10, but with a digit shown after the decimal
-     * separator if there is only one digit before the decimal separator. The default compact notation rounding strategy
+     * separator if there is only one digit before the decimal separator. The default compact notation rounding precision
      * is equivalent to:
      *
      * <pre>
-     * Rounder.integer().withMinDigits(2)
+     * Precision::integer().withMinDigits(2)
      * </pre>
      *
      * @return A CompactNotation for passing to the NumberFormatter notation() setter.
@@ -641,6 +348,9 @@ class U_I18N_API Notation : public UMemory {
     friend class impl::NumberFormatterImpl;
     friend class impl::ScientificModifier;
     friend class impl::ScientificHandler;
+
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
 };
 
 /**
@@ -687,21 +397,36 @@ class U_I18N_API ScientificNotation : public Notation {
     // Inherit constructor
     using Notation::Notation;
 
+    // Raw constructor for NumberPropertyMapper
+    ScientificNotation(int8_t fEngineeringInterval, bool fRequireMinInt, impl::digits_t fMinExponentDigits,
+                       UNumberSignDisplay fExponentSignDisplay);
+
     friend class Notation;
+
+    // So that NumberPropertyMapper can create instances
+    friend class impl::NumberPropertyMapper;
 };
 
 // Reserve extra names in case they are added as classes in the future:
-typedef Rounder DigitRounder;
+typedef Precision SignificantDigitsPrecision;
+
+// Typedefs for ICU 60/61 compatibility.
+// These will be removed in ICU 64.
+// See http://bugs.icu-project.org/trac/ticket/13746
+typedef Precision Rounder;
+typedef FractionPrecision FractionRounder;
+typedef IncrementPrecision IncrementRounder;
+typedef CurrencyPrecision CurrencyRounder;
 
 /**
- * A class that defines the rounding strategy to be used when formatting numbers in NumberFormatter.
+ * A class that defines the rounding precision to be used when formatting numbers in NumberFormatter.
  *
  * <p>
- * To create a Rounder, use one of the factory methods.
+ * To create a Precision, use one of the factory methods.
  *
  * @draft ICU 60
  */
-class U_I18N_API Rounder : public UMemory {
+class U_I18N_API Precision : public UMemory {
 
   public:
     /**
@@ -717,18 +442,18 @@ class U_I18N_API Rounder : public UMemory {
      * <p>
      * http://www.serpentine.com/blog/2011/06/29/here-be-dragons-advances-in-problems-you-didnt-even-know-you-had/
      *
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A Precision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static Rounder unlimited();
+    static Precision unlimited();
 
     /**
      * Show numbers rounded if necessary to the nearest integer.
      *
-     * @return A FractionRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static FractionRounder integer();
+    static FractionPrecision integer();
 
     /**
      * Show numbers rounded if necessary to a certain number of fraction places (numerals after the decimal separator).
@@ -754,10 +479,10 @@ class U_I18N_API Rounder : public UMemory {
      * @param minMaxFractionPlaces
      *            The minimum and maximum number of numerals to display after the decimal separator (rounding if too
      *            long or padding with zeros if too short).
-     * @return A FractionRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static FractionRounder fixedFraction(int32_t minMaxFractionPlaces);
+    static FractionPrecision fixedFraction(int32_t minMaxFractionPlaces);
 
     /**
      * Always show at least a certain number of fraction places after the decimal separator, padding with zeros if
@@ -769,10 +494,10 @@ class U_I18N_API Rounder : public UMemory {
      * @param minFractionPlaces
      *            The minimum number of numerals to display after the decimal separator (padding with zeros if
      *            necessary).
-     * @return A FractionRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static FractionRounder minFraction(int32_t minFractionPlaces);
+    static FractionPrecision minFraction(int32_t minFractionPlaces);
 
     /**
      * Show numbers rounded if necessary to a certain number of fraction places (numerals after the decimal separator).
@@ -781,10 +506,10 @@ class U_I18N_API Rounder : public UMemory {
      *
      * @param maxFractionPlaces
      *            The maximum number of numerals to display after the decimal mark (rounding if necessary).
-     * @return A FractionRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static FractionRounder maxFraction(int32_t maxFractionPlaces);
+    static FractionPrecision maxFraction(int32_t maxFractionPlaces);
 
     /**
      * Show numbers rounded if necessary to a certain number of fraction places (numerals after the decimal separator);
@@ -796,10 +521,10 @@ class U_I18N_API Rounder : public UMemory {
      *            necessary).
      * @param maxFractionPlaces
      *            The maximum number of numerals to display after the decimal separator (rounding if necessary).
-     * @return A FractionRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A FractionPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static FractionRounder minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces);
+    static FractionPrecision minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces);
 
     /**
      * Show numbers rounded if necessary to a certain number of significant digits or significant figures. Additionally,
@@ -811,10 +536,10 @@ class U_I18N_API Rounder : public UMemory {
      * @param minMaxSignificantDigits
      *            The minimum and maximum number of significant digits to display (rounding if too long or padding with
      *            zeros if too short).
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
-     * @draft ICU 60
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
+     * @draft ICU 62
      */
-    static DigitRounder fixedDigits(int32_t minMaxSignificantDigits);
+    static SignificantDigitsPrecision fixedSignificantDigits(int32_t minMaxSignificantDigits);
 
     /**
      * Always show at least a certain number of significant digits/figures, padding with zeros if necessary. Do not
@@ -825,20 +550,20 @@ class U_I18N_API Rounder : public UMemory {
      *
      * @param minSignificantDigits
      *            The minimum number of significant digits to display (padding with zeros if too short).
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
-     * @draft ICU 60
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
+     * @draft ICU 62
      */
-    static DigitRounder minDigits(int32_t minSignificantDigits);
+    static SignificantDigitsPrecision minSignificantDigits(int32_t minSignificantDigits);
 
     /**
      * Show numbers rounded if necessary to a certain number of significant digits/figures.
      *
      * @param maxSignificantDigits
      *            The maximum number of significant digits to display (rounding if too long).
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
-     * @draft ICU 60
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
+     * @draft ICU 62
      */
-    static DigitRounder maxDigits(int32_t maxSignificantDigits);
+    static SignificantDigitsPrecision maxSignificantDigits(int32_t maxSignificantDigits);
 
     /**
      * Show numbers rounded if necessary to a certain number of significant digits/figures; in addition, always show at
@@ -848,10 +573,36 @@ class U_I18N_API Rounder : public UMemory {
      *            The minimum number of significant digits to display (padding with zeros if necessary).
      * @param maxSignificantDigits
      *            The maximum number of significant digits to display (rounding if necessary).
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
-     * @draft ICU 60
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
+     * @draft ICU 62
      */
-    static DigitRounder minMaxDigits(int32_t minSignificantDigits, int32_t maxSignificantDigits);
+    static SignificantDigitsPrecision minMaxSignificantDigits(int32_t minSignificantDigits,
+                                                              int32_t maxSignificantDigits);
+
+#ifndef U_HIDE_DEPRECATED_API
+    // Compatiblity methods that will be removed in ICU 64.
+    // See http://bugs.icu-project.org/trac/ticket/13746
+
+    /** @deprecated ICU 62 */
+    static inline SignificantDigitsPrecision fixedDigits(int32_t a) {
+        return fixedSignificantDigits(a);
+    }
+
+    /** @deprecated ICU 62 */
+    static inline SignificantDigitsPrecision minDigits(int32_t a) {
+        return minSignificantDigits(a);
+    }
+
+    /** @deprecated ICU 62 */
+    static inline SignificantDigitsPrecision maxDigits(int32_t a) {
+        return maxSignificantDigits(a);
+    }
+
+    /** @deprecated ICU 62 */
+    static inline SignificantDigitsPrecision minMaxDigits(int32_t a, int32_t b) {
+        return minMaxSignificantDigits(a, b);
+    }
+#endif  /* U_HIDE_DEPRECATED_API */
 
     /**
      * Show numbers rounded if necessary to the closest multiple of a certain rounding increment. For example, if the
@@ -864,20 +615,21 @@ class U_I18N_API Rounder : public UMemory {
      * decimal separator (to display 1.2 as "1.00" and 1.3 as "1.50"), you can run:
      *
      * <pre>
-     * Rounder::increment(0.5).withMinFraction(2)
+     * Precision::increment(0.5).withMinFraction(2)
      * </pre>
      *
      * @param roundingIncrement
      *            The increment to which to round numbers.
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static IncrementRounder increment(double roundingIncrement);
+    static IncrementPrecision increment(double roundingIncrement);
 
     /**
-     * Show numbers rounded and padded according to the rules for the currency unit. The most common rounding settings
-     * for currencies include <code>Rounder.fixedFraction(2)</code>, <code>Rounder.integer()</code>, and
-     * <code>Rounder.increment(0.05)</code> for cash transactions ("nickel rounding").
+     * Show numbers rounded and padded according to the rules for the currency unit. The most common
+     * rounding precision settings for currencies include <code>Precision::fixedFraction(2)</code>,
+     * <code>Precision::integer()</code>, and <code>Precision::increment(0.05)</code> for cash transactions
+     * ("nickel rounding").
      *
      * <p>
      * The exact rounding details will be resolved at runtime based on the currency unit specified in the
@@ -887,24 +639,28 @@ class U_I18N_API Rounder : public UMemory {
      * @param currencyUsage
      *            Either STANDARD (for digital transactions) or CASH (for transactions where the rounding increment may
      *            be limited by the available denominations of cash or coins).
-     * @return A CurrencyRounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A CurrencyPrecision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    static CurrencyRounder currency(UCurrencyUsage currencyUsage);
+    static CurrencyPrecision currency(UCurrencyUsage currencyUsage);
 
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * Sets the rounding mode to use when picking the direction to round (up or down). Common values
      * include HALF_EVEN, HALF_UP, and FLOOR. The default is HALF_EVEN.
      *
      * @param roundingMode
      *            The RoundingMode to use.
-     * @return A Rounder for passing to the NumberFormatter rounding() setter.
-     * @draft ICU 60
+     * @return A Precision for passing to the NumberFormatter precision() setter.
+     * @deprecated ICU 62 Use the top-level roundingMode() setting instead.
+     *            This method will be removed in ICU 64.
+     *            See http://bugs.icu-project.org/trac/ticket/13746
      */
-    Rounder withMode(UNumberFormatRoundingMode roundingMode) const;
+    Precision withMode(UNumberFormatRoundingMode roundingMode) const;
+#endif  /* U_HIDE_DEPRECATED_API */
 
   private:
-    enum RounderType {
+    enum PrecisionType {
         RND_BOGUS,
         RND_NONE,
         RND_FRACTION,
@@ -912,11 +668,10 @@ class U_I18N_API Rounder : public UMemory {
         RND_FRACTION_SIGNIFICANT,
         RND_INCREMENT,
         RND_CURRENCY,
-        RND_PASS_THROUGH,
         RND_ERROR
     } fType;
 
-    union RounderUnion {
+    union PrecisionUnion {
         struct FractionSignificantSettings {
             // For RND_FRACTION, RND_SIGNIFICANT, and RND_FRACTION_SIGNIFICANT
             impl::digits_t fMinFrac;
@@ -927,24 +682,27 @@ class U_I18N_API Rounder : public UMemory {
         struct IncrementSettings {
             double fIncrement;
             impl::digits_t fMinFrac;
+            impl::digits_t fMaxFrac;
         } increment; // For RND_INCREMENT
         UCurrencyUsage currencyUsage; // For RND_CURRENCY
         UErrorCode errorCode; // For RND_ERROR
     } fUnion;
 
-    typedef RounderUnion::FractionSignificantSettings FractionSignificantSettings;
-    typedef RounderUnion::IncrementSettings IncrementSettings;
+    typedef PrecisionUnion::FractionSignificantSettings FractionSignificantSettings;
+    typedef PrecisionUnion::IncrementSettings IncrementSettings;
 
+    /** The Precision encapsulates the RoundingMode when used within the implementation. */
     UNumberFormatRoundingMode fRoundingMode;
 
-    Rounder(const RounderType &type, const RounderUnion &union_, UNumberFormatRoundingMode roundingMode)
+    Precision(const PrecisionType& type, const PrecisionUnion& union_,
+              UNumberFormatRoundingMode roundingMode)
             : fType(type), fUnion(union_), fRoundingMode(roundingMode) {}
 
-    Rounder(UErrorCode errorCode) : fType(RND_ERROR) {
+    Precision(UErrorCode errorCode) : fType(RND_ERROR) {
         fUnion.errorCode = errorCode;
     }
 
-    Rounder() : fType(RND_BOGUS) {}
+    Precision() : fType(RND_BOGUS) {}
 
     bool isBogus() const {
         return fType == RND_BOGUS;
@@ -958,47 +716,21 @@ class U_I18N_API Rounder : public UMemory {
         return FALSE;
     }
 
-    // On the parent type so that this method can be called internally on Rounder instances.
-    Rounder withCurrency(const CurrencyUnit &currency, UErrorCode &status) const;
-
-    /** NON-CONST: mutates the current instance. */
-    void setLocaleData(const CurrencyUnit &currency, UErrorCode &status);
-
-    void apply(impl::DecimalQuantity &value, UErrorCode &status) const;
-
-    /** Version of {@link #apply} that obeys minInt constraints. Used for scientific notation compatibility mode. */
-    void apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode status);
-
-    /**
-     * Rounding endpoint used by Engineering and Compact notation. Chooses the most appropriate multiplier (magnitude
-     * adjustment), applies the adjustment, rounds, and returns the chosen multiplier.
-     *
-     * <p>
-     * In most cases, this is simple. However, when rounding the number causes it to cross a multiplier boundary, we
-     * need to re-do the rounding. For example, to display 999,999 in Engineering notation with 2 sigfigs, first you
-     * guess the multiplier to be -3. However, then you end up getting 1000E3, which is not the correct output. You then
-     * change your multiplier to be -6, and you get 1.0E6, which is correct.
-     *
-     * @param input The quantity to process.
-     * @param producer Function to call to return a multiplier based on a magnitude.
-     * @return The number of orders of magnitude the input was adjusted by this method.
-     */
-    int32_t
-    chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
-                             UErrorCode &status);
+    // On the parent type so that this method can be called internally on Precision instances.
+    Precision withCurrency(const CurrencyUnit &currency, UErrorCode &status) const;
 
-    static FractionRounder constructFraction(int32_t minFrac, int32_t maxFrac);
+    static FractionPrecision constructFraction(int32_t minFrac, int32_t maxFrac);
 
-    static Rounder constructSignificant(int32_t minSig, int32_t maxSig);
+    static Precision constructSignificant(int32_t minSig, int32_t maxSig);
 
-    static Rounder
-    constructFractionSignificant(const FractionRounder &base, int32_t minSig, int32_t maxSig);
+    static Precision
+    constructFractionSignificant(const FractionPrecision &base, int32_t minSig, int32_t maxSig);
 
-    static IncrementRounder constructIncrement(double increment, int32_t minFrac);
+    static IncrementPrecision constructIncrement(double increment, int32_t minFrac);
 
-    static CurrencyRounder constructCurrency(UCurrencyUsage usage);
+    static CurrencyPrecision constructCurrency(UCurrencyUsage usage);
 
-    static Rounder constructPassThrough();
+    static Precision constructPassThrough();
 
     // To allow MacroProps/MicroProps to initialize bogus instances:
     friend struct impl::MacroProps;
@@ -1007,28 +739,31 @@ class U_I18N_API Rounder : public UMemory {
     // To allow NumberFormatterImpl to access isBogus() and other internal methods:
     friend class impl::NumberFormatterImpl;
 
-    // To give access to apply() and chooseMultiplierAndApply():
-    friend class impl::MutablePatternModifier;
-    friend class impl::LongNameHandler;
-    friend class impl::ScientificHandler;
-    friend class impl::CompactHandler;
+    // To allow NumberPropertyMapper to create instances from DecimalFormatProperties:
+    friend class impl::NumberPropertyMapper;
+
+    // To allow access to the main implementation class:
+    friend class impl::RoundingImpl;
 
     // To allow child classes to call private methods:
-    friend class FractionRounder;
-    friend class CurrencyRounder;
-    friend class IncrementRounder;
+    friend class FractionPrecision;
+    friend class CurrencyPrecision;
+    friend class IncrementPrecision;
+
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
 };
 
 /**
- * A class that defines a rounding strategy based on a number of fraction places and optionally significant digits to be
+ * A class that defines a rounding precision based on a number of fraction places and optionally significant digits to be
  * used when formatting numbers in NumberFormatter.
  *
  * <p>
- * To create a FractionRounder, use one of the factory methods on Rounder.
+ * To create a FractionPrecision, use one of the factory methods on Precision.
  *
  * @draft ICU 60
  */
-class U_I18N_API FractionRounder : public Rounder {
+class U_I18N_API FractionPrecision : public Precision {
   public:
     /**
      * Ensure that no less than this number of significant digits are retained when rounding according to fraction
@@ -1043,10 +778,10 @@ class U_I18N_API FractionRounder : public Rounder {
      *
      * @param minSignificantDigits
      *            The number of significant figures to guarantee.
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    Rounder withMinDigits(int32_t minSignificantDigits) const;
+    Precision withMinDigits(int32_t minSignificantDigits) const;
 
     /**
      * Ensure that no more than this number of significant digits are retained when rounding according to fraction
@@ -1062,36 +797,36 @@ class U_I18N_API FractionRounder : public Rounder {
      *
      * @param maxSignificantDigits
      *            Round the number to no more than this number of significant figures.
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    Rounder withMaxDigits(int32_t maxSignificantDigits) const;
+    Precision withMaxDigits(int32_t maxSignificantDigits) const;
 
   private:
     // Inherit constructor
-    using Rounder::Rounder;
+    using Precision::Precision;
 
     // To allow parent class to call this class's constructor:
-    friend class Rounder;
+    friend class Precision;
 };
 
 /**
- * A class that defines a rounding strategy parameterized by a currency to be used when formatting numbers in
+ * A class that defines a rounding precision parameterized by a currency to be used when formatting numbers in
  * NumberFormatter.
  *
  * <p>
- * To create a CurrencyRounder, use one of the factory methods on Rounder.
+ * To create a CurrencyPrecision, use one of the factory methods on Precision.
  *
  * @draft ICU 60
  */
-class U_I18N_API CurrencyRounder : public Rounder {
+class U_I18N_API CurrencyPrecision : public Precision {
   public:
     /**
-      * Associates a currency with this rounding strategy.
+      * Associates a currency with this rounding precision.
       *
       * <p>
       * <strong>Calling this method is <em>not required</em></strong>, because the currency specified in unit()
-      * is automatically applied to currency rounding strategies. However,
+      * is automatically applied to currency rounding precisions. However,
       * this method enables you to override that automatic association.
       *
       * <p>
@@ -1099,30 +834,30 @@ class U_I18N_API CurrencyRounder : public Rounder {
       * currency format.
       *
       * @param currency
-      *            The currency to associate with this rounding strategy.
-      * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+      *            The currency to associate with this rounding precision.
+      * @return A precision for chaining or passing to the NumberFormatter precision() setter.
       * @draft ICU 60
       */
-    Rounder withCurrency(const CurrencyUnit &currency) const;
+    Precision withCurrency(const CurrencyUnit &currency) const;
 
   private:
     // Inherit constructor
-    using Rounder::Rounder;
+    using Precision::Precision;
 
     // To allow parent class to call this class's constructor:
-    friend class Rounder;
+    friend class Precision;
 };
 
 /**
- * A class that defines a rounding strategy parameterized by a rounding increment to be used when formatting numbers in
+ * A class that defines a rounding precision parameterized by a rounding increment to be used when formatting numbers in
  * NumberFormatter.
  *
  * <p>
- * To create an IncrementRounder, use one of the factory methods on Rounder.
+ * To create an IncrementPrecision, use one of the factory methods on Precision.
  *
  * @draft ICU 60
  */
-class U_I18N_API IncrementRounder : public Rounder {
+class U_I18N_API IncrementPrecision : public Precision {
   public:
     /**
      * Specifies the minimum number of fraction digits to render after the decimal separator, padding with zeros if
@@ -1136,17 +871,17 @@ class U_I18N_API IncrementRounder : public Rounder {
      * Note: In ICU4J, this functionality is accomplished via the scale of the BigDecimal rounding increment.
      *
      * @param minFrac The minimum number of digits after the decimal separator.
-     * @return A Rounder for chaining or passing to the NumberFormatter rounding() setter.
+     * @return A precision for chaining or passing to the NumberFormatter precision() setter.
      * @draft ICU 60
      */
-    Rounder withMinFraction(int32_t minFrac) const;
+    Precision withMinFraction(int32_t minFrac) const;
 
   private:
     // Inherit constructor
-    using Rounder::Rounder;
+    using Precision::Precision;
 
     // To allow parent class to call this class's constructor:
-    friend class Rounder;
+    friend class Precision;
 };
 
 /**
@@ -1170,7 +905,6 @@ class U_I18N_API IntegerWidth : public UMemory {
      *            The minimum number of places before the decimal separator.
      * @return An IntegerWidth for chaining or passing to the NumberFormatter integerWidth() setter.
      * @draft ICU 60
-     * @see NumberFormatter
      */
     static IntegerWidth zeroFillTo(int32_t minInt);
 
@@ -1184,7 +918,6 @@ class U_I18N_API IntegerWidth : public UMemory {
      *            truncation.
      * @return An IntegerWidth for passing to the NumberFormatter integerWidth() setter.
      * @draft ICU 60
-     * @see NumberFormatter
      */
     IntegerWidth truncateAt(int32_t maxInt);
 
@@ -1193,12 +926,13 @@ class U_I18N_API IntegerWidth : public UMemory {
         struct {
             impl::digits_t fMinInt;
             impl::digits_t fMaxInt;
+            bool fFormatFailIfMoreThanMaxDigits;
         } minMaxInt;
         UErrorCode errorCode;
     } fUnion;
     bool fHasError = false;
 
-    IntegerWidth(impl::digits_t minInt, impl::digits_t maxInt);
+    IntegerWidth(impl::digits_t minInt, impl::digits_t maxInt, bool formatFailIfMoreThanMaxDigits);
 
     IntegerWidth(UErrorCode errorCode) { // NOLINT
         fUnion.errorCode = errorCode;
@@ -1209,6 +943,11 @@ class U_I18N_API IntegerWidth : public UMemory {
         fUnion.minMaxInt.fMinInt = -1;
     }
 
+    /** Returns the default instance. */
+    static IntegerWidth standard() {
+        return IntegerWidth::zeroFillTo(1);
+    }
+
     bool isBogus() const {
         return !fHasError && fUnion.minMaxInt.fMinInt == -1;
     }
@@ -1223,69 +962,214 @@ class U_I18N_API IntegerWidth : public UMemory {
 
     void apply(impl::DecimalQuantity &quantity, UErrorCode &status) const;
 
+    bool operator==(const IntegerWidth& other) const;
+
     // To allow MacroProps/MicroProps to initialize empty instances:
     friend struct impl::MacroProps;
     friend struct impl::MicroProps;
 
     // To allow NumberFormatterImpl to access isBogus() and perform other operations:
     friend class impl::NumberFormatterImpl;
-};
-
-namespace impl {
-
-// Do not enclose entire SymbolsWrapper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
-/** @internal */
-class U_I18N_API SymbolsWrapper : public UMemory {
-  public:
-    /** @internal */
-    SymbolsWrapper() : fType(SYMPTR_NONE), fPtr{nullptr} {}
 
-    /** @internal */
-    SymbolsWrapper(const SymbolsWrapper &other);
-
-    /** @internal */
-    ~SymbolsWrapper();
+    // So that NumberPropertyMapper can create instances
+    friend class impl::NumberPropertyMapper;
 
-    /** @internal */
-    SymbolsWrapper &operator=(const SymbolsWrapper &other);
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
+};
 
-#ifndef U_HIDE_INTERNAL_API
+/**
+ * A class that defines a quantity by which a number should be multiplied when formatting.
+ *
+ * <p>
+ * To create a Scale, use one of the factory methods.
+ *
+ * @draft ICU 62
+ */
+class U_I18N_API Scale : public UMemory {
+  public:
     /**
-     * The provided object is copied, but we do not adopt it.
-     * @internal
+     * Do not change the value of numbers when formatting or parsing.
+     *
+     * @return A Scale to prevent any multiplication.
+     * @draft ICU 62
      */
-    void setTo(const DecimalFormatSymbols &dfs);
+    static Scale none();
 
     /**
-     * Adopt the provided object.
-     * @internal
+     * Multiply numbers by a power of ten before formatting. Useful for combining with a percent unit:
+     *
+     * <pre>
+     * NumberFormatter::with().unit(NoUnit::percent()).multiplier(Scale::powerOfTen(2))
+     * </pre>
+     *
+     * @return A Scale for passing to the setter in NumberFormatter.
+     * @draft ICU 62
      */
-    void setTo(const NumberingSystem *ns);
+    static Scale powerOfTen(int32_t power);
 
     /**
-     * Whether the object is currently holding a DecimalFormatSymbols.
-     * @internal
+     * Multiply numbers by an arbitrary value before formatting. Useful for unit conversions.
+     *
+     * This method takes a string in a decimal number format with syntax
+     * as defined in the Decimal Arithmetic Specification, available at
+     * http://speleotrove.com/decimal
+     *
+     * Also see the version of this method that takes a double.
+     *
+     * @return A Scale for passing to the setter in NumberFormatter.
+     * @draft ICU 62
      */
-    bool isDecimalFormatSymbols() const;
+    static Scale byDecimal(StringPiece multiplicand);
 
     /**
-     * Whether the object is currently holding a NumberingSystem.
-     * @internal
+     * Multiply numbers by an arbitrary value before formatting. Useful for unit conversions.
+     *
+     * This method takes a double; also see the version of this method that takes an exact decimal.
+     *
+     * @return A Scale for passing to the setter in NumberFormatter.
+     * @draft ICU 62
      */
-    bool isNumberingSystem() const;
+    static Scale byDouble(double multiplicand);
 
     /**
-     * Get the DecimalFormatSymbols pointer. No ownership change.
-     * @internal
+     * Multiply a number by both a power of ten and by an arbitrary double value.
+     *
+     * @return A Scale for passing to the setter in NumberFormatter.
+     * @draft ICU 62
      */
-    const DecimalFormatSymbols *getDecimalFormatSymbols() const;
+    static Scale byDoubleAndPowerOfTen(double multiplicand, int32_t power);
 
-    /**
+    // We need a custom destructor for the DecNum, which means we need to declare
+    // the copy/move constructor/assignment quartet.
+
+    /** @draft ICU 62 */
+    Scale(const Scale& other);
+
+    /** @draft ICU 62 */
+    Scale& operator=(const Scale& other);
+
+    /** @draft ICU 62 */
+    Scale(Scale&& src) U_NOEXCEPT;
+
+    /** @draft ICU 62 */
+    Scale& operator=(Scale&& src) U_NOEXCEPT;
+
+    /** @draft ICU 62 */
+    ~Scale();
+
+#ifndef U_HIDE_INTERNAL_API
+    /** @internal */
+    Scale(int32_t magnitude, impl::DecNum* arbitraryToAdopt);
+#endif  /* U_HIDE_INTERNAL_API */
+
+  private:
+    int32_t fMagnitude;
+    impl::DecNum* fArbitrary;
+    UErrorCode fError;
+
+    Scale(UErrorCode error) : fMagnitude(0), fArbitrary(nullptr), fError(error) {}
+
+    Scale() : fMagnitude(0), fArbitrary(nullptr), fError(U_ZERO_ERROR) {}
+
+    bool isValid() const {
+        return fMagnitude != 0 || fArbitrary != nullptr;
+    }
+
+    UBool copyErrorTo(UErrorCode &status) const {
+        if (fError != U_ZERO_ERROR) {
+            status = fError;
+            return TRUE;
+        }
+        return FALSE;
+    }
+
+    void applyTo(impl::DecimalQuantity& quantity) const;
+
+    void applyReciprocalTo(impl::DecimalQuantity& quantity) const;
+
+    // To allow MacroProps/MicroProps to initialize empty instances:
+    friend struct impl::MacroProps;
+    friend struct impl::MicroProps;
+
+    // To allow NumberFormatterImpl to access isBogus() and perform other operations:
+    friend class impl::NumberFormatterImpl;
+
+    // To allow the helper class MultiplierFormatHandler access to private fields:
+    friend class impl::MultiplierFormatHandler;
+
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
+
+    // To allow access to parsing code:
+    friend class ::icu::numparse::impl::NumberParserImpl;
+    friend class ::icu::numparse::impl::MultiplierParseHandler;
+};
+
+namespace impl {
+
+// Do not enclose entire SymbolsWrapper with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
+/** @internal */
+class U_I18N_API SymbolsWrapper : public UMemory {
+  public:
+    /** @internal */
+    SymbolsWrapper() : fType(SYMPTR_NONE), fPtr{nullptr} {}
+
+    /** @internal */
+    SymbolsWrapper(const SymbolsWrapper &other);
+
+    /** @internal */
+    SymbolsWrapper &operator=(const SymbolsWrapper &other);
+
+    /** @internal */
+    SymbolsWrapper(SymbolsWrapper&& src) U_NOEXCEPT;
+
+    /** @internal */
+    SymbolsWrapper &operator=(SymbolsWrapper&& src) U_NOEXCEPT;
+
+    /** @internal */
+    ~SymbolsWrapper();
+
+#ifndef U_HIDE_INTERNAL_API
+
+    /**
+     * The provided object is copied, but we do not adopt it.
+     * @internal
+     */
+    void setTo(const DecimalFormatSymbols &dfs);
+
+    /**
+     * Adopt the provided object.
+     * @internal
+     */
+    void setTo(const NumberingSystem *ns);
+
+    /**
+     * Whether the object is currently holding a DecimalFormatSymbols.
+     * @internal
+     */
+    bool isDecimalFormatSymbols() const;
+
+    /**
+     * Whether the object is currently holding a NumberingSystem.
+     * @internal
+     */
+    bool isNumberingSystem() const;
+
+    /**
+     * Get the DecimalFormatSymbols pointer. No ownership change.
+     * @internal
+     */
+    const DecimalFormatSymbols *getDecimalFormatSymbols() const;
+
+    /**
      * Get the NumberingSystem pointer. No ownership change.
      * @internal
      */
     const NumberingSystem *getNumberingSystem() const;
 
+#endif  // U_HIDE_INTERNAL_API
+
     /** @internal */
     UBool copyErrorTo(UErrorCode &status) const {
         if (fType == SYMPTR_DFS && fPtr.dfs == nullptr) {
@@ -1297,7 +1181,6 @@ class U_I18N_API SymbolsWrapper : public UMemory {
         }
         return FALSE;
     }
-#endif  // U_HIDE_INTERNAL_API
 
   private:
     enum SymbolsPointerType {
@@ -1311,6 +1194,8 @@ class U_I18N_API SymbolsWrapper : public UMemory {
 
     void doCopyFrom(const SymbolsWrapper &other);
 
+    void doMoveFrom(SymbolsWrapper&& src);
+
     void doCleanup();
 };
 
@@ -1322,13 +1207,28 @@ class U_I18N_API Grouper : public UMemory {
     /** @internal */
     static Grouper forStrategy(UGroupingStrategy grouping);
 
+    /**
+     * Resolve the values in Properties to a Grouper object.
+     * @internal
+     */
+    static Grouper forProperties(const DecimalFormatProperties& properties);
+
     // Future: static Grouper forProperties(DecimalFormatProperties& properties);
 
     /** @internal */
-    Grouper(int16_t grouping1, int16_t grouping2, int16_t minGrouping)
-            : fGrouping1(grouping1), fGrouping2(grouping2), fMinGrouping(minGrouping) {}
+    Grouper(int16_t grouping1, int16_t grouping2, int16_t minGrouping, UGroupingStrategy strategy)
+            : fGrouping1(grouping1),
+              fGrouping2(grouping2),
+              fMinGrouping(minGrouping),
+              fStrategy(strategy) {}
 #endif  // U_HIDE_INTERNAL_API
 
+    /** @internal */
+    int16_t getPrimary() const;
+
+    /** @internal */
+    int16_t getSecondary() const;
+
   private:
     /**
      * The grouping sizes, with the following special values:
@@ -1342,7 +1242,7 @@ class U_I18N_API Grouper : public UMemory {
     int16_t fGrouping2;
 
     /**
-     * The minimum gropuing size, with the following special values:
+     * The minimum grouping size, with the following special values:
      * <ul>
      * <li>-2 = needs locale data
      * <li>-3 = no less than 2
@@ -1350,6 +1250,12 @@ class U_I18N_API Grouper : public UMemory {
      */
     int16_t fMinGrouping;
 
+    /**
+     * The UGroupingStrategy that was used to create this Grouper, or UNUM_GROUPING_COUNT if this
+     * was not created from a UGroupingStrategy.
+     */
+    UGroupingStrategy fStrategy;
+
     Grouper() : fGrouping1(-3) {};
 
     bool isBogus() const {
@@ -1367,6 +1273,12 @@ class U_I18N_API Grouper : public UMemory {
 
     // To allow NumberFormatterImpl to access isBogus() and perform other operations:
     friend class NumberFormatterImpl;
+
+    // To allow NumberParserImpl to perform setLocaleData():
+    friend class ::icu::numparse::impl::NumberParserImpl;
+
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
 };
 
 // Do not enclose entire Padder with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
@@ -1381,6 +1293,9 @@ class U_I18N_API Padder : public UMemory {
     static Padder codePoints(UChar32 cp, int32_t targetWidth, UNumberFormatPadPosition position);
 #endif  // U_HIDE_INTERNAL_API
 
+    /** @internal */
+    static Padder forProperties(const DecimalFormatProperties& properties);
+
   private:
     UChar32 fWidth;  // -3 = error; -2 = bogus; -1 = no padding
     union {
@@ -1427,6 +1342,9 @@ class U_I18N_API Padder : public UMemory {
 
     // To allow NumberFormatterImpl to access isBogus() and perform other operations:
     friend class impl::NumberFormatterImpl;
+
+    // To allow access to the skeleton generation code:
+    friend class impl::GeneratorHelpers;
 };
 
 // Do not enclose entire MacroProps with #ifndef U_HIDE_INTERNAL_API, needed for a protected field
@@ -1442,7 +1360,10 @@ struct U_I18N_API MacroProps : public UMemory {
     MeasureUnit perUnit; // = NoUnit::base();
 
     /** @internal */
-    Rounder rounder;  // = Rounder();  (bogus)
+    Precision precision;  // = Precision();  (bogus)
+
+    /** @internal */
+    UNumberFormatRoundingMode roundingMode = UNUM_ROUND_HALFEVEN;
 
     /** @internal */
     Grouper grouper;  // = Grouper();  (bogus)
@@ -1468,20 +1389,33 @@ struct U_I18N_API MacroProps : public UMemory {
     UNumberDecimalSeparatorDisplay decimal = UNUM_DECIMAL_SEPARATOR_COUNT;
 
     /** @internal */
-    PluralRules *rules = nullptr;  // no ownership
+    Scale scale;  // = Scale();  (benign value)
+
+    /** @internal */
+    const AffixPatternProvider* affixProvider = nullptr;  // no ownership
+
+    /** @internal */
+    const PluralRules* rules = nullptr;  // no ownership
+
+    /** @internal */
+    const CurrencySymbols* currencySymbols = nullptr;  // no ownership
 
     /** @internal */
     int32_t threshold = DEFAULT_THRESHOLD;
+
+    /** @internal */
     Locale locale;
 
+    // NOTE: Uses default copy and move constructors.
+
     /**
      * Check all members for errors.
      * @internal
      */
     bool copyErrorTo(UErrorCode &status) const {
-        return notation.copyErrorTo(status) || rounder.copyErrorTo(status) ||
+        return notation.copyErrorTo(status) || precision.copyErrorTo(status) ||
                padder.copyErrorTo(status) || integerWidth.copyErrorTo(status) ||
-               symbols.copyErrorTo(status);
+               symbols.copyErrorTo(status) || scale.copyErrorTo(status);
     }
 };
 
@@ -1505,7 +1439,7 @@ class U_I18N_API NumberFormatterSettings {
      *
      * <p>
      * All notation styles will be properly localized with locale data, and all notation styles are compatible with
-     * units, rounding strategies, and other number formatter settings.
+     * units, rounding precisions, and other number formatter settings.
      *
      * <p>
      * Pass this method the return value of a {@link Notation} factory method. For example:
@@ -1522,7 +1456,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see Notation
      * @draft ICU 60
      */
-    Derived notation(const Notation &notation) const;
+    Derived notation(const Notation &notation) const &;
+
+    /**
+     * Overload of notation() for use on an rvalue reference.
+     *
+     * @param notation
+     *            The notation strategy to use.
+     * @return The fluent chain.
+     * @see #notation
+     * @draft ICU 62
+     */
+    Derived notation(const Notation &notation) &&;
 
     /**
      * Specifies the unit (unit of measure, currency, or percent) to associate with rendered numbers.
@@ -1534,7 +1479,7 @@ class U_I18N_API NumberFormatterSettings {
      * </ul>
      *
      * All units will be properly localized with locale data, and all units are compatible with notation styles,
-     * rounding strategies, and other number formatter settings.
+     * rounding precisions, and other number formatter settings.
      *
      * Pass this method any instance of {@link MeasureUnit}. For units of measure (which often involve the
      * factory methods that return a pointer):
@@ -1568,7 +1513,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see #perUnit
      * @draft ICU 60
      */
-    Derived unit(const icu::MeasureUnit &unit) const;
+    Derived unit(const icu::MeasureUnit &unit) const &;
+
+    /**
+     * Overload of unit() for use on an rvalue reference.
+     *
+     * @param unit
+     *            The unit to render.
+     * @return The fluent chain.
+     * @see #unit
+     * @draft ICU 62
+     */
+    Derived unit(const icu::MeasureUnit &unit) &&;
 
     /**
      * Like unit(), but takes ownership of a pointer.  Convenient for use with the MeasureFormat factory
@@ -1585,7 +1541,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see MeasureUnit
      * @draft ICU 60
      */
-    Derived adoptUnit(icu::MeasureUnit *unit) const;
+    Derived adoptUnit(icu::MeasureUnit *unit) const &;
+
+    /**
+     * Overload of adoptUnit() for use on an rvalue reference.
+     *
+     * @param unit
+     *            The unit to render.
+     * @return The fluent chain.
+     * @see #adoptUnit
+     * @draft ICU 62
+     */
+    Derived adoptUnit(icu::MeasureUnit *unit) &&;
 
     /**
      * Sets a unit to be used in the denominator. For example, to format "3 m/s", pass METER to the unit and SECOND to
@@ -1604,7 +1571,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see #unit
      * @draft ICU 61
      */
-    Derived perUnit(const icu::MeasureUnit &perUnit) const;
+    Derived perUnit(const icu::MeasureUnit &perUnit) const &;
+
+    /**
+     * Overload of perUnit() for use on an rvalue reference.
+     *
+     * @param perUnit
+     *            The unit to render in the denominator.
+     * @return The fluent chain.
+     * @see #perUnit
+     * @draft ICU 62
+     */
+    Derived perUnit(const icu::MeasureUnit &perUnit) &&;
 
     /**
      * Like perUnit(), but takes ownership of a pointer.  Convenient for use with the MeasureFormat factory
@@ -1623,10 +1601,21 @@ class U_I18N_API NumberFormatterSettings {
      * @see MeasureUnit
      * @draft ICU 61
      */
-    Derived adoptPerUnit(icu::MeasureUnit *perUnit) const;
+    Derived adoptPerUnit(icu::MeasureUnit *perUnit) const &;
 
     /**
-     * Specifies the rounding strategy to use when formatting numbers.
+     * Overload of adoptPerUnit() for use on an rvalue reference.
+     *
+     * @param perUnit
+     *            The unit to render in the denominator.
+     * @return The fluent chain.
+     * @see #adoptPerUnit
+     * @draft ICU 62
+     */
+    Derived adoptPerUnit(icu::MeasureUnit *perUnit) &&;
+
+    /**
+     * Specifies the rounding precision to use when formatting numbers.
      *
      * <ul>
      * <li>Round to 3 decimal places: "3.142"
@@ -1636,27 +1625,77 @@ class U_I18N_API NumberFormatterSettings {
      * </ul>
      *
      * <p>
-     * Pass this method the return value of one of the factory methods on {@link Rounder}. For example:
+     * Pass this method the return value of one of the factory methods on {@link Precision}. For example:
      *
      * <pre>
-     * NumberFormatter::with().rounding(Rounder::fixedFraction(2))
+     * NumberFormatter::with().precision(Precision::fixedFraction(2))
      * </pre>
      *
      * <p>
      * In most cases, the default rounding strategy is to round to 6 fraction places; i.e.,
-     * <code>Rounder.maxFraction(6)</code>. The exceptions are if compact notation is being used, then the compact
+     * <code>Precision.maxFraction(6)</code>. The exceptions are if compact notation is being used, then the compact
      * notation rounding strategy is used (see {@link Notation#compactShort} for details), or if the unit is a currency,
-     * then standard currency rounding is used, which varies from currency to currency (see {@link Rounder#currency} for
+     * then standard currency rounding is used, which varies from currency to currency (see {@link Precision#currency} for
      * details).
      *
-     * @param rounder
-     *            The rounding strategy to use.
+     * @param precision
+     *            The rounding precision to use.
      * @return The fluent chain.
-     * @see Rounder
-     * @provisional This API might change or be removed in a future release.
-     * @draft ICU 60
+     * @see Precision
+     * @draft ICU 62
+     */
+    Derived precision(const Precision& precision) const &;
+
+    /**
+     * Overload of precision() for use on an rvalue reference.
+     *
+     * @param precision
+     *            The rounding precision to use.
+     * @return The fluent chain.
+     * @see #precision
+     * @draft ICU 62
+     */
+    Derived precision(const Precision& precision) &&;
+
+#ifndef U_HIDE_DEPRECATED_API
+    // Compatibility method that will be removed in ICU 64.
+    // Use precision() instead.
+    // See http://bugs.icu-project.org/trac/ticket/13746
+    /** @deprecated ICU 62 */
+    Derived rounding(const Rounder& rounder) const & {
+        return precision(rounder);
+    }
+#endif  /* U_HIDE_DEPRECATED_API */
+
+    /**
+     * Specifies how to determine the direction to round a number when it has more digits than fit in the
+     * desired precision.  When formatting 1.235:
+     *
+     * <ul>
+     * <li>Ceiling rounding mode with integer precision: "2"
+     * <li>Half-down rounding mode with 2 fixed fraction digits: "1.23"
+     * <li>Half-up rounding mode with 2 fixed fraction digits: "1.24"
+     * </ul>
+     *
+     * The default is HALF_EVEN. For more information on rounding mode, see the ICU userguide here:
+     *
+     * http://userguide.icu-project.org/formatparse/numbers/rounding-modes
+     *
+     * @param roundingMode The rounding mode to use.
+     * @return The fluent chain.
+     * @draft ICU 62
+     */
+    Derived roundingMode(UNumberFormatRoundingMode roundingMode) const &;
+
+    /**
+     * Overload of roundingMode() for use on an rvalue reference.
+     *
+     * @param roundingMode The rounding mode to use.
+     * @return The fluent chain.
+     * @see #roundingMode
+     * @draft ICU 62
      */
-    Derived rounding(const Rounder &rounder) const;
+    Derived roundingMode(UNumberFormatRoundingMode roundingMode) &&;
 
     /**
      * Specifies the grouping strategy to use when formatting numbers.
@@ -1685,7 +1724,19 @@ class U_I18N_API NumberFormatterSettings {
      * @return The fluent chain.
      * @draft ICU 61
      */
-    Derived grouping(const UGroupingStrategy &strategy) const;
+    Derived grouping(UGroupingStrategy strategy) const &;
+
+    /**
+     * Overload of grouping() for use on an rvalue reference.
+     *
+     * @param strategy
+     *            The grouping strategy to use.
+     * @return The fluent chain.
+     * @see #grouping
+     * @provisional This API might change or be removed in a future release.
+     * @draft ICU 62
+     */
+    Derived grouping(UGroupingStrategy strategy) &&;
 
     /**
      * Specifies the minimum and maximum number of digits to render before the decimal mark.
@@ -1711,7 +1762,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see IntegerWidth
      * @draft ICU 60
      */
-    Derived integerWidth(const IntegerWidth &style) const;
+    Derived integerWidth(const IntegerWidth &style) const &;
+
+    /**
+     * Overload of integerWidth() for use on an rvalue reference.
+     *
+     * @param style
+     *            The integer width to use.
+     * @return The fluent chain.
+     * @see #integerWidth
+     * @draft ICU 62
+     */
+    Derived integerWidth(const IntegerWidth &style) &&;
 
     /**
      * Specifies the symbols (decimal separator, grouping separator, percent sign, numerals, etc.) to use when rendering
@@ -1741,8 +1803,8 @@ class U_I18N_API NumberFormatterSettings {
      * after passing it into the fluent chain will not be seen.
      *
      * <p>
-     * <strong>Note:</strong> Calling this method will override the NumberingSystem previously specified in
-     * {@link #symbols(NumberingSystem)}.
+     * <strong>Note:</strong> Calling this method will override any previously specified DecimalFormatSymbols
+     * or NumberingSystem.
      *
      * <p>
      * The default is to choose the symbols based on the locale specified in the fluent chain.
@@ -1753,7 +1815,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see DecimalFormatSymbols
      * @draft ICU 60
      */
-    Derived symbols(const DecimalFormatSymbols &symbols) const;
+    Derived symbols(const DecimalFormatSymbols &symbols) const &;
+
+    /**
+     * Overload of symbols() for use on an rvalue reference.
+     *
+     * @param symbols
+     *            The DecimalFormatSymbols to use.
+     * @return The fluent chain.
+     * @see #symbols
+     * @draft ICU 62
+     */
+    Derived symbols(const DecimalFormatSymbols &symbols) &&;
 
     /**
      * Specifies that the given numbering system should be used when fetching symbols.
@@ -1773,8 +1846,8 @@ class U_I18N_API NumberFormatterSettings {
      * </pre>
      *
      * <p>
-     * <strong>Note:</strong> Calling this method will override the DecimalFormatSymbols previously specified in
-     * {@link #symbols(DecimalFormatSymbols)}.
+     * <strong>Note:</strong> Calling this method will override any previously specified DecimalFormatSymbols
+     * or NumberingSystem.
      *
      * <p>
      * The default is to choose the best numbering system for the locale.
@@ -1788,7 +1861,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see NumberingSystem
      * @draft ICU 60
      */
-    Derived adoptSymbols(NumberingSystem *symbols) const;
+    Derived adoptSymbols(NumberingSystem *symbols) const &;
+
+    /**
+     * Overload of adoptSymbols() for use on an rvalue reference.
+     *
+     * @param symbols
+     *            The NumberingSystem to use.
+     * @return The fluent chain.
+     * @see #adoptSymbols
+     * @draft ICU 62
+     */
+    Derived adoptSymbols(NumberingSystem *symbols) &&;
 
     /**
      * Sets the width of the unit (measure unit or currency).  Most common values:
@@ -1815,7 +1899,18 @@ class U_I18N_API NumberFormatterSettings {
      * @see UNumberUnitWidth
      * @draft ICU 60
      */
-    Derived unitWidth(const UNumberUnitWidth &width) const;
+    Derived unitWidth(UNumberUnitWidth width) const &;
+
+    /**
+     * Overload of unitWidth() for use on an rvalue reference.
+     *
+     * @param width
+     *            The width to use when rendering numbers.
+     * @return The fluent chain.
+     * @see #unitWidth
+     * @draft ICU 62
+     */
+    Derived unitWidth(UNumberUnitWidth width) &&;
 
     /**
      * Sets the plus/minus sign display strategy. Most common values:
@@ -1836,14 +1931,24 @@ class U_I18N_API NumberFormatterSettings {
      * <p>
      * The default is AUTO sign display.
      *
-     * @param width
+     * @param style
      *            The sign display strategy to use when rendering numbers.
      * @return The fluent chain
      * @see UNumberSignDisplay
-     * @provisional This API might change or be removed in a future release.
      * @draft ICU 60
      */
-    Derived sign(const UNumberSignDisplay &width) const;
+    Derived sign(UNumberSignDisplay style) const &;
+
+    /**
+     * Overload of sign() for use on an rvalue reference.
+     *
+     * @param style
+     *            The sign display strategy to use when rendering numbers.
+     * @return The fluent chain.
+     * @see #sign
+     * @draft ICU 62
+     */
+    Derived sign(UNumberSignDisplay style) &&;
 
     /**
      * Sets the decimal separator display strategy. This affects integer numbers with no fraction part. Most common
@@ -1864,23 +1969,73 @@ class U_I18N_API NumberFormatterSettings {
      * <p>
      * The default is AUTO decimal separator display.
      *
-     * @param width
+     * @param style
      *            The decimal separator display strategy to use when rendering numbers.
      * @return The fluent chain
      * @see UNumberDecimalSeparatorDisplay
-     * @provisional This API might change or be removed in a future release.
      * @draft ICU 60
      */
-    Derived decimal(const UNumberDecimalSeparatorDisplay &width) const;
+    Derived decimal(UNumberDecimalSeparatorDisplay style) const &;
+
+    /**
+     * Overload of decimal() for use on an rvalue reference.
+     *
+     * @param style
+     *            The decimal separator display strategy to use when rendering numbers.
+     * @return The fluent chain.
+     * @see #decimal
+     * @draft ICU 62
+     */
+    Derived decimal(UNumberDecimalSeparatorDisplay style) &&;
+
+    /**
+     * Sets a scale (multiplier) to be used to scale the number by an arbitrary amount before formatting.
+     * Most common values:
+     *
+     * <ul>
+     * <li>Multiply by 100: useful for percentages.
+     * <li>Multiply by an arbitrary value: useful for unit conversions.
+     * </ul>
+     *
+     * <p>
+     * Pass an element from a {@link Scale} factory method to this setter. For example:
+     *
+     * <pre>
+     * NumberFormatter::with().scale(Scale::powerOfTen(2))
+     * </pre>
+     *
+     * <p>
+     * The default is to not apply any multiplier.
+     *
+     * @param scale
+     *            The scale to apply when rendering numbers.
+     * @return The fluent chain
+     * @draft ICU 62
+     */
+    Derived scale(const Scale &scale) const &;
+
+    /**
+     * Overload of scale() for use on an rvalue reference.
+     *
+     * @param scale
+     *            The scale to apply when rendering numbers.
+     * @return The fluent chain.
+     * @see #scale
+     * @draft ICU 62
+     */
+    Derived scale(const Scale &scale) &&;
 
 #ifndef U_HIDE_INTERNAL_API
 
     /**
-     * Set the padding strategy. May be added to ICU 61; see #13338.
+     * Set the padding strategy. May be added in the future; see #13338.
      *
      * @internal ICU 60: This API is ICU internal only.
      */
-    Derived padding(const impl::Padder &padder) const;
+    Derived padding(const impl::Padder &padder) const &;
+
+    /** @internal */
+    Derived padding(const impl::Padder &padder) &&;
 
     /**
      * Internal fluent setter to support a custom regulation threshold. A threshold of 1 causes the data structures to
@@ -1888,10 +2043,45 @@ class U_I18N_API NumberFormatterSettings {
      *
      * @internal ICU 60: This API is ICU internal only.
      */
-    Derived threshold(int32_t threshold) const;
+    Derived threshold(int32_t threshold) const &;
+
+    /** @internal */
+    Derived threshold(int32_t threshold) &&;
+
+    /**
+     * Internal fluent setter to overwrite the entire macros object.
+     *
+     * @internal ICU 60: This API is ICU internal only.
+     */
+    Derived macros(const impl::MacroProps& macros) const &;
+
+    /** @internal */
+    Derived macros(const impl::MacroProps& macros) &&;
+
+    /** @internal */
+    Derived macros(impl::MacroProps&& macros) const &;
+
+    /** @internal */
+    Derived macros(impl::MacroProps&& macros) &&;
 
 #endif  /* U_HIDE_INTERNAL_API */
 
+    /**
+     * Creates a skeleton string representation of this number formatter. A skeleton string is a
+     * locale-agnostic serialized form of a number formatter.
+     *
+     * Not all options are capable of being represented in the skeleton string; for example, a
+     * DecimalFormatSymbols object. If any such option is encountered, the error code is set to
+     * U_UNSUPPORTED_ERROR.
+     *
+     * The returned skeleton is in normalized form, such that two number formatters with equivalent
+     * behavior should produce the same skeleton.
+     *
+     * @return A number skeleton string with behavior corresponding to this number formatter.
+     * @draft ICU 62
+     */
+    UnicodeString toSkeleton(UErrorCode& status) const;
+
     /**
      * Sets the UErrorCode if an error occurred in the fluent chain.
      * Preserves older error codes in the outErrorCode.
@@ -1905,7 +2095,9 @@ class U_I18N_API NumberFormatterSettings {
         }
         fMacros.copyErrorTo(outErrorCode);
         return U_FAILURE(outErrorCode);
-    }
+    };
+
+    // NOTE: Uses default copy and move constructors.
 
   protected:
     impl::MacroProps fMacros;
@@ -1944,21 +2136,58 @@ class U_I18N_API UnlocalizedNumberFormatter
      * @return The fluent chain.
      * @draft ICU 60
      */
-    LocalizedNumberFormatter locale(const icu::Locale &locale) const;
+    LocalizedNumberFormatter locale(const icu::Locale &locale) const &;
+
+    /**
+     * Overload of locale() for use on an rvalue reference.
+     *
+     * @param locale
+     *            The locale to use when loading data for number formatting.
+     * @return The fluent chain.
+     * @see #locale
+     * @draft ICU 62
+     */
+    LocalizedNumberFormatter locale(const icu::Locale &locale) &&;
+
+    /**
+     * Default constructor: puts the formatter into a valid but undefined state.
+     *
+     * @draft ICU 62
+     */
+    UnlocalizedNumberFormatter() = default;
 
     // Make default copy constructor call the NumberFormatterSettings copy constructor.
     /**
      * Returns a copy of this UnlocalizedNumberFormatter.
      * @draft ICU 60
      */
-    UnlocalizedNumberFormatter(const UnlocalizedNumberFormatter &other) : UnlocalizedNumberFormatter(
-            static_cast<const NumberFormatterSettings<UnlocalizedNumberFormatter> &>(other)) {}
+    UnlocalizedNumberFormatter(const UnlocalizedNumberFormatter &other);
+
+    /**
+     * Move constructor:
+     * The source UnlocalizedNumberFormatter will be left in a valid but undefined state.
+     * @draft ICU 62
+     */
+    UnlocalizedNumberFormatter(UnlocalizedNumberFormatter&& src) U_NOEXCEPT;
+
+    /**
+     * Copy assignment operator.
+     * @draft ICU 62
+     */
+    UnlocalizedNumberFormatter& operator=(const UnlocalizedNumberFormatter& other);
+
+    /**
+     * Move assignment operator:
+     * The source UnlocalizedNumberFormatter will be left in a valid but undefined state.
+     * @draft ICU 62
+     */
+    UnlocalizedNumberFormatter& operator=(UnlocalizedNumberFormatter&& src) U_NOEXCEPT;
 
   private:
-    UnlocalizedNumberFormatter() = default;
+    explicit UnlocalizedNumberFormatter(const NumberFormatterSettings<UnlocalizedNumberFormatter>& other);
 
     explicit UnlocalizedNumberFormatter(
-            const NumberFormatterSettings<UnlocalizedNumberFormatter> &other);
+            NumberFormatterSettings<UnlocalizedNumberFormatter>&& src) U_NOEXCEPT;
 
     // To give the fluent setters access to this class's constructor:
     friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;
@@ -2016,15 +2245,99 @@ class U_I18N_API LocalizedNumberFormatter
      * @return A FormattedNumber object; call .toString() to get the string.
      * @draft ICU 60
      */
-    FormattedNumber formatDecimal(StringPiece value, UErrorCode &status) const;
+    FormattedNumber formatDecimal(StringPiece value, UErrorCode& status) const;
+
+#ifndef U_HIDE_INTERNAL_API
+
+    /** Internal method.
+     * @internal
+     */
+    FormattedNumber formatDecimalQuantity(const impl::DecimalQuantity& dq, UErrorCode& status) const;
+
+    /** Internal method for DecimalFormat compatibility.
+     * @internal
+     */
+    void getAffixImpl(bool isPrefix, bool isNegative, UnicodeString& result, UErrorCode& status) const;
+
+    /**
+     * Internal method for testing.
+     * @internal
+     */
+    const impl::NumberFormatterImpl* getCompiled() const;
+
+    /**
+     * Internal method for testing.
+     * @internal
+     */
+    int32_t getCallCount() const;
+
+#endif
+
+    /**
+     * Creates a representation of this LocalizedNumberFormat as an icu::Format, enabling the use
+     * of this number formatter with APIs that need an object of that type, such as MessageFormat.
+     *
+     * This API is not intended to be used other than for enabling API compatibility. The formatDouble,
+     * formatInt, and formatDecimal methods should normally be used when formatting numbers, not the Format
+     * object returned by this method.
+     *
+     * The caller owns the returned object and must delete it when finished.
+     *
+     * @return A Format wrapping this LocalizedNumberFormatter.
+     * @draft ICU 62
+     */
+    Format* toFormat(UErrorCode& status) const;
+
+    /**
+     * Default constructor: puts the formatter into a valid but undefined state.
+     *
+     * @draft ICU 62
+     */
+    LocalizedNumberFormatter() = default;
 
     // Make default copy constructor call the NumberFormatterSettings copy constructor.
     /**
      * Returns a copy of this LocalizedNumberFormatter.
      * @draft ICU 60
      */
-    LocalizedNumberFormatter(const LocalizedNumberFormatter &other) : LocalizedNumberFormatter(
-            static_cast<const NumberFormatterSettings<LocalizedNumberFormatter> &>(other)) {}
+    LocalizedNumberFormatter(const LocalizedNumberFormatter &other);
+
+    /**
+     * Move constructor:
+     * The source LocalizedNumberFormatter will be left in a valid but undefined state.
+     * @draft ICU 62
+     */
+    LocalizedNumberFormatter(LocalizedNumberFormatter&& src) U_NOEXCEPT;
+
+    /**
+     * Copy assignment operator.
+     * @draft ICU 62
+     */
+    LocalizedNumberFormatter& operator=(const LocalizedNumberFormatter& other);
+
+    /**
+     * Move assignment operator:
+     * The source LocalizedNumberFormatter will be left in a valid but undefined state.
+     * @draft ICU 62
+     */
+    LocalizedNumberFormatter& operator=(LocalizedNumberFormatter&& src) U_NOEXCEPT;
+
+#ifndef U_HIDE_INTERNAL_API
+
+    /**
+     * This is the core entrypoint to the number formatting pipeline. It performs self-regulation: a static code path
+     * for the first few calls, and compiling a more efficient data structure if called repeatedly.
+     *
+     * <p>
+     * This function is very hot, being called in every call to the number formatting pipeline.
+     *
+     * @param results
+     *            The results object. This method will mutate it to save the results.
+     * @internal
+     */
+    void formatImpl(impl::UFormattedNumberData *results, UErrorCode &status) const;
+
+#endif
 
     /**
      * Destruct this LocalizedNumberFormatter, cleaning up any memory it might own.
@@ -2033,27 +2346,25 @@ class U_I18N_API LocalizedNumberFormatter
     ~LocalizedNumberFormatter();
 
   private:
+    // Note: fCompiled can't be a LocalPointer because impl::NumberFormatterImpl is defined in an internal
+    // header, and LocalPointer needs the full class definition in order to delete the instance.
     const impl::NumberFormatterImpl* fCompiled {nullptr};
     char fUnsafeCallCount[8] {};  // internally cast to u_atomic_int32_t
 
-    LocalizedNumberFormatter() = default;
+    explicit LocalizedNumberFormatter(const NumberFormatterSettings<LocalizedNumberFormatter>& other);
 
-    explicit LocalizedNumberFormatter(const NumberFormatterSettings<LocalizedNumberFormatter> &other);
+    explicit LocalizedNumberFormatter(NumberFormatterSettings<LocalizedNumberFormatter>&& src) U_NOEXCEPT;
 
     LocalizedNumberFormatter(const impl::MacroProps &macros, const Locale &locale);
 
+    LocalizedNumberFormatter(impl::MacroProps &&macros, const Locale &locale);
+
+    void lnfMoveHelper(LocalizedNumberFormatter&& src);
+
     /**
-     * This is the core entrypoint to the number formatting pipeline. It performs self-regulation: a static code path
-     * for the first few calls, and compiling a more efficient data structure if called repeatedly.
-     *
-     * <p>
-     * This function is very hot, being called in every call to the number formatting pipeline.
-     *
-     * @param results
-     *            The results object. This method takes ownership.
-     * @return The formatted number result.
+     * @return true if the compiled formatter is available.
      */
-    FormattedNumber formatImpl(impl::NumberFormatterResults *results, UErrorCode &status) const;
+    bool computeCompiled(UErrorCode& status) const;
 
     // To give the fluent setters access to this class's constructor:
     friend class NumberFormatterSettings<UnlocalizedNumberFormatter>;
@@ -2071,25 +2382,57 @@ class U_I18N_API LocalizedNumberFormatter
  */
 class U_I18N_API FormattedNumber : public UMemory {
   public:
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * Returns a UnicodeString representation of the formatted number.
      *
      * @return a UnicodeString containing the localized number.
-     * @draft ICU 60
+     * @deprecated ICU 62 Use the version of this method with an error code instead.
+     *                This method was never @stable and will be removed in a future release.
+     *                See http://bugs.icu-project.org/trac/ticket/13746
      */
     UnicodeString toString() const;
+#endif  /* U_HIDE_DEPRECATED_API */
+
+    /**
+     * Returns a UnicodeString representation of the formatted number.
+     *
+     * @param status
+     *            Set if an error occurs while formatting the number to the UnicodeString.
+     * @return a UnicodeString containing the localized number.
+     * @draft ICU 62
+     */
+    UnicodeString toString(UErrorCode& status) const;
 
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * Appends the formatted number to an Appendable.
      *
      * @param appendable
      *            The Appendable to which to append the formatted number string.
      * @return The same Appendable, for chaining.
-     * @draft ICU 60
+     * @deprecated ICU 62 Use the version of this method with an error code instead.
+     *                This method was never @stable and will be removed in a future release.
+     *                See http://bugs.icu-project.org/trac/ticket/13746
      * @see Appendable
      */
     Appendable &appendTo(Appendable &appendable);
+#endif  /* U_HIDE_DEPRECATED_API */
 
+    /**
+     * Appends the formatted number to an Appendable.
+     *
+     * @param appendable
+     *            The Appendable to which to append the formatted number string.
+     * @param status
+     *            Set if an error occurs while formatting the number to the Appendable.
+     * @return The same Appendable, for chaining.
+     * @draft ICU 62
+     * @see Appendable
+     */
+    Appendable &appendTo(Appendable &appendable, UErrorCode& status);
+
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * Determine the start and end indices of the first occurrence of the given <em>field</em> in the output string.
      * This allows you to determine the locations of the integer part, fraction part, and sign.
@@ -2106,11 +2449,47 @@ class U_I18N_API FormattedNumber : public UMemory {
      *            The FieldPosition to populate with the start and end indices of the desired field.
      * @param status
      *            Set if an error occurs while populating the FieldPosition.
-     * @draft ICU 60
+     * @deprecated ICU 62 Use {@link #nextFieldPosition} instead. This method will be removed in a future
+     *             release. See http://bugs.icu-project.org/trac/ticket/13746
      * @see UNumberFormatFields
      */
     void populateFieldPosition(FieldPosition &fieldPosition, UErrorCode &status);
+#endif  /* U_HIDE_DEPRECATED_API */
+
+    /**
+     * Determines the start and end indices of the next occurrence of the given <em>field</em> in the
+     * output string. This allows you to determine the locations of, for example, the integer part,
+     * fraction part, or symbols.
+     *
+     * If a field occurs just once, calling this method will find that occurrence and return it. If a
+     * field occurs multiple times, this method may be called repeatedly with the following pattern:
+     *
+     * <pre>
+     * FieldPosition fpos(UNUM_GROUPING_SEPARATOR_FIELD);
+     * while (formattedNumber.nextFieldPosition(fpos, status)) {
+     *   // do something with fpos.
+     * }
+     * </pre>
+     *
+     * This method is useful if you know which field to query. If you want all available field position
+     * information, use #getAllFieldPositions().
+     *
+     * @param fieldPosition
+     *            Input+output variable. On input, the "field" property determines which field to look
+     *            up, and the "beginIndex" and "endIndex" properties determine where to begin the search.
+     *            On output, the "beginIndex" is set to the beginning of the first occurrence of the
+     *            field with either begin or end indices after the input indices, "endIndex" is set to
+     *            the end of that occurrence of the field (exclusive index). If a field position is not
+     *            found, the method returns FALSE and the FieldPosition may or may not be changed.
+     * @param status
+     *            Set if an error occurs while populating the FieldPosition.
+     * @return TRUE if a new occurrence of the field was found; FALSE otherwise.
+     * @draft ICU 62
+     * @see UNumberFormatFields
+     */
+    UBool nextFieldPosition(FieldPosition& fieldPosition, UErrorCode& status) const;
 
+#ifndef U_HIDE_DEPRECATED_API
     /**
      * Export the formatted number to a FieldPositionIterator. This allows you to determine which characters in
      * the output string correspond to which <em>fields</em>, such as the integer part, fraction part, and sign.
@@ -2122,10 +2501,67 @@ class U_I18N_API FormattedNumber : public UMemory {
      *            The FieldPositionIterator to populate with all of the fields present in the formatted number.
      * @param status
      *            Set if an error occurs while populating the FieldPositionIterator.
-     * @draft ICU 60
+     * @deprecated ICU 62 Use {@link #getAllFieldPositions} instead. This method will be removed in a
+     *             future release. See http://bugs.icu-project.org/trac/ticket/13746
      * @see UNumberFormatFields
      */
     void populateFieldPositionIterator(FieldPositionIterator &iterator, UErrorCode &status);
+#endif  /* U_HIDE_DEPRECATED_API */
+
+    /**
+     * Export the formatted number to a FieldPositionIterator. This allows you to determine which characters in
+     * the output string correspond to which <em>fields</em>, such as the integer part, fraction part, and sign.
+     *
+     * If information on only one field is needed, use #nextFieldPosition() instead.
+     *
+     * @param iterator
+     *            The FieldPositionIterator to populate with all of the fields present in the formatted number.
+     * @param status
+     *            Set if an error occurs while populating the FieldPositionIterator.
+     * @draft ICU 62
+     * @see UNumberFormatFields
+     */
+    void getAllFieldPositions(FieldPositionIterator &iterator, UErrorCode &status) const;
+
+#ifndef U_HIDE_INTERNAL_API
+
+    /**
+     *  Gets the raw DecimalQuantity for plural rule selection.
+     *  @internal
+     */
+    void getDecimalQuantity(impl::DecimalQuantity& output, UErrorCode& status) const;
+
+    /**
+     * Populates the mutable builder type FieldPositionIteratorHandler.
+     * @internal
+     */
+    void getAllFieldPositionsImpl(FieldPositionIteratorHandler& fpih, UErrorCode& status) const;
+
+#endif
+
+    /**
+     * Copying not supported; use move constructor instead.
+     */
+    FormattedNumber(const FormattedNumber&) = delete;
+
+    /**
+     * Copying not supported; use move assignment instead.
+     */
+    FormattedNumber& operator=(const FormattedNumber&) = delete;
+
+    /**
+     * Move constructor:
+     * Leaves the source FormattedNumber in an undefined state.
+     * @draft ICU 62
+     */
+    FormattedNumber(FormattedNumber&& src) U_NOEXCEPT;
+
+    /**
+     * Move assignment:
+     * Leaves the source FormattedNumber in an undefined state.
+     * @draft ICU 62
+     */
+    FormattedNumber& operator=(FormattedNumber&& src) U_NOEXCEPT;
 
     /**
      * Destruct an instance of FormattedNumber, cleaning up any memory it might own.
@@ -2134,13 +2570,17 @@ class U_I18N_API FormattedNumber : public UMemory {
     ~FormattedNumber();
 
   private:
-    // Can't use LocalPointer because NumberFormatterResults is forward-declared
-    const impl::NumberFormatterResults *fResults;
+    // Can't use LocalPointer because UFormattedNumberData is forward-declared
+    const impl::UFormattedNumberData *fResults;
 
     // Error code for the terminal methods
     UErrorCode fErrorCode;
 
-    explicit FormattedNumber(impl::NumberFormatterResults *results)
+    /**
+     * Internal constructor from data type. Adopts the data pointer.
+     * @internal
+     */
+    explicit FormattedNumber(impl::UFormattedNumberData *results)
         : fResults(results), fErrorCode(U_ZERO_ERROR) {};
 
     explicit FormattedNumber(UErrorCode errorCode)
@@ -2177,9 +2617,21 @@ class U_I18N_API NumberFormatter final {
      */
     static LocalizedNumberFormatter withLocale(const Locale &locale);
 
+    /**
+     * Call this method at the beginning of a NumberFormatter fluent chain to create an instance based
+     * on a given number skeleton string.
+     *
+     * @param skeleton
+     *            The skeleton string off of which to base this NumberFormatter.
+     * @param status
+     *            Set to U_NUMBER_SKELETON_SYNTAX_ERROR if the skeleton was invalid.
+     * @return An UnlocalizedNumberFormatter, to be used for chaining.
+     * @draft ICU 62
+     */
+    static UnlocalizedNumberFormatter forSkeleton(const UnicodeString& skeleton, UErrorCode& status);
+
     /**
      * Use factory methods instead of the constructor to create a NumberFormatter.
-     * @draft ICU 60
      */
     NumberFormatter() = delete;
 };
diff --git a/deps/icu-small/source/i18n/unicode/numfmt.h b/deps/icu-small/source/i18n/unicode/numfmt.h
index 1332f5256628e3..572e6afc71b807 100644
--- a/deps/icu-small/source/i18n/unicode/numfmt.h
+++ b/deps/icu-small/source/i18n/unicode/numfmt.h
@@ -555,16 +555,18 @@ class U_I18N_API NumberFormat : public Format {
                                   UnicodeString& appendTo,
                                   FieldPositionIterator* posIter,
                                   UErrorCode& status) const;
-public:
+
+// Can't use #ifndef U_HIDE_INTERNAL_API because these are virtual methods
+
     /**
      * Format a decimal number.
-     * The number is a DigitList wrapper onto a floating point decimal number.
+     * The number is a DecimalQuantity wrapper onto a floating point decimal number.
      * The default implementation in NumberFormat converts the decimal number
      * to a double and formats that.  Subclasses of NumberFormat that want
      * to specifically handle big decimal numbers must override this method.
      * class DecimalFormat does so.
      *
-     * @param number    The number, a DigitList format Decimal Floating Point.
+     * @param number    The number, a DecimalQuantity format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param posIter   On return, can be used to iterate over positions
@@ -573,20 +575,20 @@ class U_I18N_API NumberFormat : public Format {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
+    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                   UnicodeString& appendTo,
                                   FieldPositionIterator* posIter,
                                   UErrorCode& status) const;
 
     /**
      * Format a decimal number.
-     * The number is a DigitList wrapper onto a floating point decimal number.
+     * The number is a DecimalQuantity wrapper onto a floating point decimal number.
      * The default implementation in NumberFormat converts the decimal number
      * to a double and formats that.  Subclasses of NumberFormat that want
      * to specifically handle big decimal numbers must override this method.
      * class DecimalFormat does so.
      *
-     * @param number    The number, a DigitList format Decimal Floating Point.
+     * @param number    The number, a DecimalQuantity format Decimal Floating Point.
      * @param appendTo  Output parameter to receive result.
      *                  Result is appended to existing contents.
      * @param pos       On input: an alignment field, if desired.
@@ -595,13 +597,11 @@ class U_I18N_API NumberFormat : public Format {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
+    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                   UnicodeString& appendTo,
                                   FieldPosition& pos,
                                   UErrorCode& status) const;
 
-public:
-
    /**
     * Return a long if possible (e.g. within range LONG_MAX,
     * LONG_MAX], and with no decimals), otherwise a double.  If
diff --git a/deps/icu-small/source/i18n/unicode/plurrule.h b/deps/icu-small/source/i18n/unicode/plurrule.h
index d372d79c845179..03dea3f1b92988 100644
--- a/deps/icu-small/source/i18n/unicode/plurrule.h
+++ b/deps/icu-small/source/i18n/unicode/plurrule.h
@@ -44,7 +44,6 @@ U_NAMESPACE_BEGIN
 
 class Hashtable;
 class IFixedDecimal;
-class VisibleDigitsWithExponent;
 class RuleChain;
 class PluralRuleParser;
 class PluralKeywordEnumeration;
@@ -348,30 +347,10 @@ class U_I18N_API PluralRules : public UObject {
     UnicodeString select(double number) const;
 
 #ifndef U_HIDE_INTERNAL_API
-    /**
-     * Given a number and a format, returns the keyword of the first applicable
-     * rule for this PluralRules object.
-     * Note: This internal preview interface may be removed in the future if
-     * an architecturally cleaner solution reaches stable status.
-     * @param obj The numeric object for which the rule should be determined.
-     * @param fmt The NumberFormat specifying how the number will be formatted
-     *        (this can affect the plural form, e.g. "1 dollar" vs "1.0 dollars").
-     * @param status  Input/output parameter. If at entry this indicates a
-     *                failure status, the method returns immediately; otherwise
-     *                this is set to indicate the outcome of the call.
-     * @return The keyword of the selected rule. Undefined in the case of an error.
-     * @internal ICU 59 technology preview, may be removed in the future
-     */
-    UnicodeString select(const Formattable& obj, const NumberFormat& fmt, UErrorCode& status) const;
-
     /**
       * @internal
       */
     UnicodeString select(const IFixedDecimal &number) const;
-    /**
-      * @internal
-      */
-    UnicodeString select(const VisibleDigitsWithExponent &number) const;
 #endif  /* U_HIDE_INTERNAL_API */
 
     /**
diff --git a/deps/icu-small/source/i18n/unicode/rbnf.h b/deps/icu-small/source/i18n/unicode/rbnf.h
index d8d33420c2a015..2d284909f8a1d4 100644
--- a/deps/icu-small/source/i18n/unicode/rbnf.h
+++ b/deps/icu-small/source/i18n/unicode/rbnf.h
@@ -884,7 +884,7 @@ class U_I18N_API RuleBasedNumberFormat : public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
+    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                   UnicodeString& appendTo,
                                   FieldPositionIterator* posIter,
                                   UErrorCode& status) const;
@@ -906,7 +906,7 @@ class U_I18N_API RuleBasedNumberFormat : public NumberFormat {
      * @return          Reference to 'appendTo' parameter.
      * @internal
      */
-    virtual UnicodeString& format(const DigitList &number,
+    virtual UnicodeString& format(const number::impl::DecimalQuantity &number,
                                   UnicodeString& appendTo,
                                   FieldPosition& pos,
                                   UErrorCode& status) const;
diff --git a/deps/icu-small/source/i18n/unicode/scientificnumberformatter.h b/deps/icu-small/source/i18n/unicode/scientificnumberformatter.h
index 30edee7ecce289..6c99a246625e2e 100644
--- a/deps/icu-small/source/i18n/unicode/scientificnumberformatter.h
+++ b/deps/icu-small/source/i18n/unicode/scientificnumberformatter.h
@@ -24,7 +24,6 @@
 U_NAMESPACE_BEGIN
 
 class FieldPositionIterator;
-class DecimalFormatStaticSets;
 class DecimalFormatSymbols;
 class DecimalFormat;
 class Formattable;
@@ -150,7 +149,6 @@ class U_I18N_API ScientificNumberFormatter : public UObject {
                 const UnicodeString &original,
                 FieldPositionIterator &fpi,
                 const UnicodeString &preExponent,
-                const DecimalFormatStaticSets &decimalFormatSets,
                 UnicodeString &appendTo,
                 UErrorCode &status) const = 0;
     private:
@@ -165,7 +163,6 @@ class U_I18N_API ScientificNumberFormatter : public UObject {
                 const UnicodeString &original,
                 FieldPositionIterator &fpi,
                 const UnicodeString &preExponent,
-                const DecimalFormatStaticSets &decimalFormatSets,
                 UnicodeString &appendTo,
                 UErrorCode &status) const;
     };
@@ -184,7 +181,6 @@ class U_I18N_API ScientificNumberFormatter : public UObject {
                 const UnicodeString &original,
                 FieldPositionIterator &fpi,
                 const UnicodeString &preExponent,
-                const DecimalFormatStaticSets &decimalFormatSets,
                 UnicodeString &appendTo,
                 UErrorCode &status) const;
     private:
@@ -211,7 +207,6 @@ class U_I18N_API ScientificNumberFormatter : public UObject {
     UnicodeString fPreExponent;
     DecimalFormat *fDecimalFormat;
     Style *fStyle;
-    const DecimalFormatStaticSets *fStaticSets;
 
 };
 
diff --git a/deps/icu-small/source/i18n/unicode/smpdtfmt.h b/deps/icu-small/source/i18n/unicode/smpdtfmt.h
index 9801b29bdb749b..305412b8d1535f 100644
--- a/deps/icu-small/source/i18n/unicode/smpdtfmt.h
+++ b/deps/icu-small/source/i18n/unicode/smpdtfmt.h
@@ -50,6 +50,10 @@ class TimeZoneFormat;
 class SharedNumberFormat;
 class SimpleDateFormatMutableNFs;
 
+namespace number {
+class LocalizedNumberFormatter;
+}
+
 /**
  *
  * SimpleDateFormat is a concrete class for formatting and parsing dates in a
@@ -1268,7 +1272,6 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
                    int32_t fieldNum,
                    FieldPositionHandler& handler,
                    Calendar& cal,
-                   SimpleDateFormatMutableNFs &mutableNFs,
                    UErrorCode& status) const; // in case of illegal argument
 
     /**
@@ -1284,7 +1287,7 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
      * @param minDigits Minimum number of digits the result should have
      * @param maxDigits Maximum number of digits the result should have
      */
-    void zeroPaddingNumber(NumberFormat *currentNumberFormat,
+    void zeroPaddingNumber(const NumberFormat *currentNumberFormat,
                            UnicodeString &appendTo,
                            int32_t value,
                            int32_t minDigits,
@@ -1414,21 +1417,21 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
      */
     int32_t subParse(const UnicodeString& text, int32_t& start, char16_t ch, int32_t count,
                      UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
-                     int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType, SimpleDateFormatMutableNFs &mutableNFs,
+                     int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType,
                      int32_t *dayPeriod=NULL) const;
 
     void parseInt(const UnicodeString& text,
                   Formattable& number,
                   ParsePosition& pos,
                   UBool allowNegative,
-                  NumberFormat *fmt) const;
+                  const NumberFormat *fmt) const;
 
     void parseInt(const UnicodeString& text,
                   Formattable& number,
                   int32_t maxDigits,
                   ParsePosition& pos,
                   UBool allowNegative,
-                  NumberFormat *fmt) const;
+                  const NumberFormat *fmt) const;
 
     int32_t checkIntSuffix(const UnicodeString& text, int32_t start,
                            int32_t patLoc, UBool isNegative) const;
@@ -1495,6 +1498,16 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
      */
     int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos) const;
 
+    /**
+     * Initialize LocalizedNumberFormatter instances used for speedup.
+     */
+    void initFastNumberFormatters(UErrorCode& status);
+
+    /**
+     * Delete the LocalizedNumberFormatter instances used for speedup.
+     */
+    void freeFastNumberFormatters();
+
     /**
      * Initialize NumberFormat instances used for numbering system overrides.
      */
@@ -1518,7 +1531,7 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
     /**
      * Lazy TimeZoneFormat instantiation, semantically const
      */
-    TimeZoneFormat *tzFormat() const;
+    TimeZoneFormat *tzFormat(UErrorCode &status) const;
 
     const NumberFormat* getNumberFormatByIndex(UDateFormatField index) const;
 
@@ -1611,6 +1624,20 @@ class U_I18N_API SimpleDateFormat: public DateFormat {
      */
     const SharedNumberFormat    **fSharedNumberFormatters;
 
+    enum NumberFormatterKey {
+        SMPDTFMT_NF_1x10,
+        SMPDTFMT_NF_2x10,
+        SMPDTFMT_NF_3x10,
+        SMPDTFMT_NF_4x10,
+        SMPDTFMT_NF_2x2,
+        SMPDTFMT_NF_COUNT
+    };
+
+    /**
+     * Number formatters pre-allocated for fast performance on the most common integer lengths.
+     */
+    const number::LocalizedNumberFormatter* fFastNumberFormatters[SMPDTFMT_NF_COUNT] = {};
+
     UBool fHaveDefaultCentury;
 
     BreakIterator* fCapitalizationBrkIter;
diff --git a/deps/icu-small/source/i18n/unicode/timezone.h b/deps/icu-small/source/i18n/unicode/timezone.h
index d4cd7cb36d326a..bbbb6b958e4514 100644
--- a/deps/icu-small/source/i18n/unicode/timezone.h
+++ b/deps/icu-small/source/i18n/unicode/timezone.h
@@ -284,6 +284,8 @@ class U_I18N_API TimeZone : public UObject {
      * and may return a different TimeZone from the one returned by
      * TimeZone::createDefault().
      *
+     * <p>This function is not thread safe.</p>
+     *
      * @return  A new instance of TimeZone detected from the current host system
      *          configuration.
      * @stable ICU 55
diff --git a/deps/icu-small/source/i18n/unicode/unum.h b/deps/icu-small/source/i18n/unicode/unum.h
index 0e7b9fffbab2b2..8b76014b1683da 100644
--- a/deps/icu-small/source/i18n/unicode/unum.h
+++ b/deps/icu-small/source/i18n/unicode/unum.h
@@ -29,12 +29,13 @@
 
 /**
  * \file
- * \brief C API: NumberFormat
+ * \brief C API: Compatibility APIs for number formatting.
  *
  * <h2> Number Format C API </h2>
  *
- * <p><strong>IMPORTANT:</strong> New users with C++ capabilities are
- * strongly encouraged to see if numberformatter.h fits their use case.
+ * <p><strong>IMPORTANT:</strong> New users with are strongly encouraged to
+ * see if unumberformatter.h fits their use case.  Although not deprecated,
+ * this header is provided for backwards compatibility only.
  *
  * Number Format C API  Provides functions for
  * formatting and parsing a number.  Also provides methods for
@@ -399,6 +400,10 @@ typedef enum UNumberFormatFields {
  * number format is opened using the given pattern, which must conform
  * to the syntax described in DecimalFormat or RuleBasedNumberFormat,
  * respectively.
+ *
+ * <p><strong>NOTE::</strong> New users with are strongly encouraged to
+ * use unumf_openWithSkeletonAndLocale instead of unum_open.
+ *
  * @param pattern A pattern specifying the format to use.
  * This parameter is ignored unless the style is
  * UNUM_PATTERN_DECIMAL or UNUM_PATTERN_RULEBASED.
@@ -1013,6 +1018,8 @@ typedef enum UNumberFormatAttribute {
     * <p>Example: setting the scale to 3, 123 formats as "123,000"
     * <p>Example: setting the scale to -4, 123 formats as "0.0123"
     *
+    * This setting is analogous to getMultiplierScale() and setMultiplierScale() in decimfmt.h.
+    *
    * @stable ICU 51 */
   UNUM_SCALE = 21,
 #ifndef U_HIDE_INTERNAL_API
@@ -1052,7 +1059,7 @@ typedef enum UNumberFormatAttribute {
    * Default: 0 (unset)
    * @stable ICU 50
    */
-  UNUM_PARSE_NO_EXPONENT,
+  UNUM_PARSE_NO_EXPONENT = 0x1001,
 
   /**
    * if this attribute is set to 1, specifies that, if the pattern contains a
@@ -1067,7 +1074,21 @@ typedef enum UNumberFormatAttribute {
   /* The following cannot be #ifndef U_HIDE_INTERNAL_API, needed in .h file variable declararions */
   /** Limit of boolean attributes.
    * @internal */
-  UNUM_LIMIT_BOOLEAN_ATTRIBUTE = 0x1003
+  UNUM_LIMIT_BOOLEAN_ATTRIBUTE = 0x1003,
+
+  /**
+   * Whether parsing is sensitive to case (lowercase/uppercase).
+   * TODO: Add to the test suite.
+   * @internal This API is a technical preview. It may change in an upcoming release.
+   */
+  UNUM_PARSE_CASE_SENSITIVE = 0x1004,
+
+  /**
+   * Formatting: whether to show the plus sign on non-negative numbers.
+   * TODO: Add to the test suite.
+   * @internal This API is a technical preview. It may change in an upcoming release.
+   */
+  UNUM_SIGN_ALWAYS_SHOWN = 0x1005,
 } UNumberFormatAttribute;
 
 /**
diff --git a/deps/icu-small/source/i18n/unicode/unumberformatter.h b/deps/icu-small/source/i18n/unicode/unumberformatter.h
new file mode 100644
index 00000000000000..b37f80c503a76d
--- /dev/null
+++ b/deps/icu-small/source/i18n/unicode/unumberformatter.h
@@ -0,0 +1,666 @@
+// © 2018 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+#ifndef __UNUMBERFORMATTER_H__
+#define __UNUMBERFORMATTER_H__
+
+#include "unicode/ufieldpositer.h"
+#include "unicode/umisc.h"
+
+
+/**
+ * \file
+ * \brief C-compatible API for localized number formatting; not recommended for C++.
+ *
+ * This is the C-compatible version of the NumberFormatter API introduced in ICU 60. C++ users should
+ * include unicode/numberformatter.h and use the proper C++ APIs.
+ *
+ * The C API accepts a number skeleton string for specifying the settings for formatting, which covers a
+ * very large subset of all possible number formatting features. For more information on number skeleton
+ * strings, see unicode/numberformatter.h.
+ *
+ * When using UNumberFormatter, which is treated as immutable, the results are exported to a mutable
+ * UFormattedNumber object, which you subsequently use for populating your string buffer or iterating over
+ * the fields.
+ *
+ * Example code:
+ * <pre>
+ * // Setup:
+ * UErrorCode ec = U_ZERO_ERROR;
+ * UNumberFormatter* uformatter = unumf_openForSkeletonAndLocale(u"precision-integer", -1, "en", &ec);
+ * UFormattedNumber* uresult = unumf_openResult(&ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Format a double:
+ * unumf_formatDouble(uformatter, 5142.3, uresult, &ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Export the string to a malloc'd buffer:
+ * int32_t len = unumf_resultToString(uresult, NULL, 0, &ec);
+ * // at this point, ec == U_BUFFER_OVERFLOW_ERROR
+ * ec = U_ZERO_ERROR;
+ * UChar* buffer = (UChar*) malloc((len+1)*sizeof(UChar));
+ * unumf_resultToString(uresult, buffer, len+1, &ec);
+ * if (U_FAILURE(ec)) { return; }
+ * // buffer should equal "5,142"
+ *
+ * // Cleanup:
+ * unumf_close(uformatter);
+ * unumf_closeResult(uresult);
+ * free(buffer);
+ * </pre>
+ *
+ * If you are a C++ user linking against the C libraries, you can use the LocalPointer versions of these
+ * APIs. The following example uses LocalPointer with the decimal number and field position APIs:
+ *
+ * <pre>
+ * // Setup:
+ * LocalUNumberFormatterPointer uformatter(unumf_openForSkeletonAndLocale(u"percent", -1, "en", &ec));
+ * LocalUFormattedNumberPointer uresult(unumf_openResult(&ec));
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Format a decimal number:
+ * unumf_formatDecimal(uformatter.getAlias(), "9.87E-3", -1, uresult.getAlias(), &ec);
+ * if (U_FAILURE(ec)) { return; }
+ *
+ * // Get the location of the percent sign:
+ * UFieldPosition ufpos = {UNUM_PERCENT_FIELD, 0, 0};
+ * unumf_resultNextFieldPosition(uresult.getAlias(), &ufpos, &ec);
+ * // ufpos should contain beginIndex=7 and endIndex=8 since the string is "0.00987%"
+ *
+ * // No need to do any cleanup since we are using LocalPointer.
+ * </pre>
+ */
+
+
+#ifndef U_HIDE_DRAFT_API
+/**
+ * An enum declaring how to render units, including currencies. Example outputs when formatting 123 USD and 123
+ * meters in <em>en-CA</em>:
+ *
+ * <p>
+ * <ul>
+ * <li>NARROW*: "$123.00" and "123 m"
+ * <li>SHORT: "US$ 123.00" and "123 m"
+ * <li>FULL_NAME: "123.00 US dollars" and "123 meters"
+ * <li>ISO_CODE: "USD 123.00" and undefined behavior
+ * <li>HIDDEN: "123.00" and "123"
+ * </ul>
+ *
+ * <p>
+ * This enum is similar to {@link com.ibm.icu.text.MeasureFormat.FormatWidth}.
+ *
+ * @draft ICU 60
+ */
+typedef enum UNumberUnitWidth {
+    /**
+     * Print an abbreviated version of the unit name. Similar to SHORT, but always use the shortest available
+     * abbreviation or symbol. This option can be used when the context hints at the identity of the unit. For more
+     * information on the difference between NARROW and SHORT, see SHORT.
+     *
+     * <p>
+     * In CLDR, this option corresponds to the "Narrow" format for measure units and the "¤¤¤¤¤" placeholder for
+     * currencies.
+     *
+     * @draft ICU 60
+     */
+            UNUM_UNIT_WIDTH_NARROW,
+
+    /**
+     * Print an abbreviated version of the unit name. Similar to NARROW, but use a slightly wider abbreviation or
+     * symbol when there may be ambiguity. This is the default behavior.
+     *
+     * <p>
+     * For example, in <em>es-US</em>, the SHORT form for Fahrenheit is "{0} °F", but the NARROW form is "{0}°",
+     * since Fahrenheit is the customary unit for temperature in that locale.
+     *
+     * <p>
+     * In CLDR, this option corresponds to the "Short" format for measure units and the "¤" placeholder for
+     * currencies.
+     *
+     * @draft ICU 60
+     */
+            UNUM_UNIT_WIDTH_SHORT,
+
+    /**
+     * Print the full name of the unit, without any abbreviations.
+     *
+     * <p>
+     * In CLDR, this option corresponds to the default format for measure units and the "¤¤¤" placeholder for
+     * currencies.
+     *
+     * @draft ICU 60
+     */
+            UNUM_UNIT_WIDTH_FULL_NAME,
+
+    /**
+     * Use the three-digit ISO XXX code in place of the symbol for displaying currencies. The behavior of this
+     * option is currently undefined for use with measure units.
+     *
+     * <p>
+     * In CLDR, this option corresponds to the "¤¤" placeholder for currencies.
+     *
+     * @draft ICU 60
+     */
+            UNUM_UNIT_WIDTH_ISO_CODE,
+
+    /**
+     * Format the number according to the specified unit, but do not display the unit. For currencies, apply
+     * monetary symbols and formats as with SHORT, but omit the currency symbol. For measure units, the behavior is
+     * equivalent to not specifying the unit at all.
+     *
+     * @draft ICU 60
+     */
+            UNUM_UNIT_WIDTH_HIDDEN,
+
+    /**
+     * One more than the highest UNumberUnitWidth value.
+     *
+     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
+     */
+            UNUM_UNIT_WIDTH_COUNT
+} UNumberUnitWidth;
+#endif  /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+/**
+ * An enum declaring the strategy for when and how to display grouping separators (i.e., the
+ * separator, often a comma or period, after every 2-3 powers of ten). The choices are several
+ * pre-built strategies for different use cases that employ locale data whenever possible. Example
+ * outputs for 1234 and 1234567 in <em>en-IN</em>:
+ *
+ * <ul>
+ * <li>OFF: 1234 and 12345
+ * <li>MIN2: 1234 and 12,34,567
+ * <li>AUTO: 1,234 and 12,34,567
+ * <li>ON_ALIGNED: 1,234 and 12,34,567
+ * <li>THOUSANDS: 1,234 and 1,234,567
+ * </ul>
+ *
+ * <p>
+ * The default is AUTO, which displays grouping separators unless the locale data says that grouping
+ * is not customary. To force grouping for all numbers greater than 1000 consistently across locales,
+ * use ON_ALIGNED. On the other hand, to display grouping less frequently than the default, use MIN2
+ * or OFF. See the docs of each option for details.
+ *
+ * <p>
+ * Note: This enum specifies the strategy for grouping sizes. To set which character to use as the
+ * grouping separator, use the "symbols" setter.
+ *
+ * @draft ICU 61 -- TODO: This should be renamed to UNumberGroupingStrategy before promoting to stable,
+ * for consistency with the other enums.
+ */
+typedef enum UGroupingStrategy {
+    /**
+     * Do not display grouping separators in any locale.
+     *
+     * @draft ICU 61
+     */
+            UNUM_GROUPING_OFF,
+
+    /**
+     * Display grouping using locale defaults, except do not show grouping on values smaller than
+     * 10000 (such that there is a <em>minimum of two digits</em> before the first separator).
+     *
+     * <p>
+     * Note that locales may restrict grouping separators to be displayed only on 1 million or
+     * greater (for example, ee and hu) or disable grouping altogether (for example, bg currency).
+     *
+     * <p>
+     * Locale data is used to determine whether to separate larger numbers into groups of 2
+     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
+     *
+     * @draft ICU 61
+     */
+            UNUM_GROUPING_MIN2,
+
+    /**
+     * Display grouping using the default strategy for all locales. This is the default behavior.
+     *
+     * <p>
+     * Note that locales may restrict grouping separators to be displayed only on 1 million or
+     * greater (for example, ee and hu) or disable grouping altogether (for example, bg currency).
+     *
+     * <p>
+     * Locale data is used to determine whether to separate larger numbers into groups of 2
+     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
+     *
+     * @draft ICU 61
+     */
+            UNUM_GROUPING_AUTO,
+
+    /**
+     * Always display the grouping separator on values of at least 1000.
+     *
+     * <p>
+     * This option ignores the locale data that restricts or disables grouping, described in MIN2 and
+     * AUTO. This option may be useful to normalize the alignment of numbers, such as in a
+     * spreadsheet.
+     *
+     * <p>
+     * Locale data is used to determine whether to separate larger numbers into groups of 2
+     * (customary in South Asia) or groups of 3 (customary in Europe and the Americas).
+     *
+     * @draft ICU 61
+     */
+            UNUM_GROUPING_ON_ALIGNED,
+
+    /**
+     * Use the Western defaults: groups of 3 and enabled for all numbers 1000 or greater. Do not use
+     * locale data for determining the grouping strategy.
+     *
+     * @draft ICU 61
+     */
+            UNUM_GROUPING_THOUSANDS,
+
+    /**
+     * One more than the highest UGroupingStrategy value.
+     *
+     * @internal ICU 62: The numeric value may change over time; see ICU ticket #12420.
+     */
+            UNUM_GROUPING_COUNT
+
+} UGroupingStrategy;
+#endif  /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+/**
+ * An enum declaring how to denote positive and negative numbers. Example outputs when formatting
+ * 123, 0, and -123 in <em>en-US</em>:
+ *
+ * <ul>
+ * <li>AUTO: "123", "0", and "-123"
+ * <li>ALWAYS: "+123", "+0", and "-123"
+ * <li>NEVER: "123", "0", and "123"
+ * <li>ACCOUNTING: "$123", "$0", and "($123)"
+ * <li>ACCOUNTING_ALWAYS: "+$123", "+$0", and "($123)"
+ * <li>EXCEPT_ZERO: "+123", "0", and "-123"
+ * <li>ACCOUNTING_EXCEPT_ZERO: "+$123", "$0", and "($123)"
+ * </ul>
+ *
+ * <p>
+ * The exact format, including the position and the code point of the sign, differ by locale.
+ *
+ * @draft ICU 60
+ */
+typedef enum UNumberSignDisplay {
+    /**
+     * Show the minus sign on negative numbers, and do not show the sign on positive numbers. This is the default
+     * behavior.
+     *
+     * @draft ICU 60
+     */
+            UNUM_SIGN_AUTO,
+
+    /**
+     * Show the minus sign on negative numbers and the plus sign on positive numbers, including zero.
+     * To hide the sign on zero, see {@link UNUM_SIGN_EXCEPT_ZERO}.
+     *
+     * @draft ICU 60
+     */
+            UNUM_SIGN_ALWAYS,
+
+    /**
+     * Do not show the sign on positive or negative numbers.
+     *
+     * @draft ICU 60
+     */
+            UNUM_SIGN_NEVER,
+
+    /**
+     * Use the locale-dependent accounting format on negative numbers, and do not show the sign on positive numbers.
+     *
+     * <p>
+     * The accounting format is defined in CLDR and varies by locale; in many Western locales, the format is a pair
+     * of parentheses around the number.
+     *
+     * <p>
+     * Note: Since CLDR defines the accounting format in the monetary context only, this option falls back to the
+     * AUTO sign display strategy when formatting without a currency unit. This limitation may be lifted in the
+     * future.
+     *
+     * @draft ICU 60
+     */
+            UNUM_SIGN_ACCOUNTING,
+
+    /**
+     * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
+     * positive numbers, including zero. For more information on the accounting format, see the
+     * ACCOUNTING sign display strategy. To hide the sign on zero, see
+     * {@link UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO}.
+     *
+     * @draft ICU 60
+     */
+            UNUM_SIGN_ACCOUNTING_ALWAYS,
+
+    /**
+     * Show the minus sign on negative numbers and the plus sign on positive numbers. Do not show a
+     * sign on zero.
+     *
+     * @draft ICU 61
+     */
+            UNUM_SIGN_EXCEPT_ZERO,
+
+    /**
+     * Use the locale-dependent accounting format on negative numbers, and show the plus sign on
+     * positive numbers. Do not show a sign on zero. For more information on the accounting format,
+     * see the ACCOUNTING sign display strategy.
+     *
+     * @draft ICU 61
+     */
+            UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO,
+
+    /**
+     * One more than the highest UNumberSignDisplay value.
+     *
+     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
+     */
+            UNUM_SIGN_COUNT
+} UNumberSignDisplay;
+#endif  /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+/**
+ * An enum declaring how to render the decimal separator.
+ *
+ * <p>
+ * <ul>
+ * <li>UNUM_DECIMAL_SEPARATOR_AUTO: "1", "1.1"
+ * <li>UNUM_DECIMAL_SEPARATOR_ALWAYS: "1.", "1.1"
+ * </ul>
+ */
+typedef enum UNumberDecimalSeparatorDisplay {
+    /**
+     * Show the decimal separator when there are one or more digits to display after the separator, and do not show
+     * it otherwise. This is the default behavior.
+     *
+     * @draft ICU 60
+     */
+            UNUM_DECIMAL_SEPARATOR_AUTO,
+
+    /**
+     * Always show the decimal separator, even if there are no digits to display after the separator.
+     *
+     * @draft ICU 60
+     */
+            UNUM_DECIMAL_SEPARATOR_ALWAYS,
+
+    /**
+     * One more than the highest UNumberDecimalSeparatorDisplay value.
+     *
+     * @internal ICU 60: The numeric value may change over time; see ICU ticket #12420.
+     */
+            UNUM_DECIMAL_SEPARATOR_COUNT
+} UNumberDecimalSeparatorDisplay;
+#endif  /* U_HIDE_DRAFT_API */
+
+#ifndef U_HIDE_DRAFT_API
+/**
+ * C-compatible version of icu::number::LocalizedNumberFormatter.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @draft ICU 62
+ */
+struct UNumberFormatter;
+typedef struct UNumberFormatter UNumberFormatter;
+
+
+/**
+ * C-compatible version of icu::number::FormattedNumber.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @draft ICU 62
+ */
+struct UFormattedNumber;
+typedef struct UFormattedNumber UFormattedNumber;
+
+
+/**
+ * Creates a new UNumberFormatter for the given skeleton string and locale. This is currently the only
+ * method for creating a new UNumberFormatter.
+ *
+ * Objects of type UNumberFormatter returned by this method are threadsafe.
+ *
+ * For more details on skeleton strings, see the documentation in numberformatter.h. For more details on
+ * the usage of this API, see the documentation at the top of unumberformatter.h.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param skeleton The skeleton string, like u"percent precision-integer"
+ * @param skeletonLen The number of UChars in the skeleton string, or -1 it it is NUL-terminated.
+ * @param locale The NUL-terminated locale ID.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT UNumberFormatter* U_EXPORT2
+unumf_openForSkeletonAndLocale(const UChar* skeleton, int32_t skeletonLen, const char* locale,
+                               UErrorCode* ec);
+
+
+/**
+ * Creates a new UFormattedNumber for holding the result of a number formatting operation.
+ *
+ * Objects of type UFormattedNumber are not guaranteed to be threadsafe.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT UFormattedNumber* U_EXPORT2
+unumf_openResult(UErrorCode* ec);
+
+
+/**
+ * Uses a UNumberFormatter to format an integer to a UFormattedNumber. A string, field position, and other
+ * information can be retrieved from the UFormattedNumber.
+ *
+ * The UNumberFormatter can be shared between threads. Each thread should have its own local
+ * UFormattedNumber, however, for storing the result of the formatting operation.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uformatter A formatter object created by unumf_openForSkeletonAndLocale or similar.
+ * @param value The number to be formatted.
+ * @param uresult The object that will be mutated to store the result; see unumf_openResult.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_formatInt(const UNumberFormatter* uformatter, int64_t value, UFormattedNumber* uresult,
+                UErrorCode* ec);
+
+
+/**
+ * Uses a UNumberFormatter to format a double to a UFormattedNumber. A string, field position, and other
+ * information can be retrieved from the UFormattedNumber.
+ *
+ * The UNumberFormatter can be shared between threads. Each thread should have its own local
+ * UFormattedNumber, however, for storing the result of the formatting operation.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uformatter A formatter object created by unumf_openForSkeletonAndLocale or similar.
+ * @param value The number to be formatted.
+ * @param uresult The object that will be mutated to store the result; see unumf_openResult.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_formatDouble(const UNumberFormatter* uformatter, double value, UFormattedNumber* uresult,
+                   UErrorCode* ec);
+
+
+/**
+ * Uses a UNumberFormatter to format a decimal number to a UFormattedNumber. A string, field position, and
+ * other information can be retrieved from the UFormattedNumber.
+ *
+ * The UNumberFormatter can be shared between threads. Each thread should have its own local
+ * UFormattedNumber, however, for storing the result of the formatting operation.
+ *
+ * The syntax of the unformatted number is a "numeric string" as defined in the Decimal Arithmetic
+ * Specification, available at http://speleotrove.com/decimal
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uformatter A formatter object created by unumf_openForSkeletonAndLocale or similar.
+ * @param value The numeric string to be formatted.
+ * @param valueLen The length of the numeric string, or -1 if it is NUL-terminated.
+ * @param uresult The object that will be mutated to store the result; see unumf_openResult.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_formatDecimal(const UNumberFormatter* uformatter, const char* value, int32_t valueLen,
+                    UFormattedNumber* uresult, UErrorCode* ec);
+
+
+/**
+ * Extracts the result number string out of a UFormattedNumber to a UChar buffer if possible.
+ * If bufferCapacity is greater than the required length, a terminating NUL is written.
+ * If bufferCapacity is less than the required length, an error code is set.
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uresult The object containing the formatted number.
+ * @param buffer Where to save the string output.
+ * @param bufferCapacity The number of UChars available in the buffer.
+ * @param ec Set if an error occurs.
+ * @return The required length.
+ * @draft ICU 62
+ */
+U_DRAFT int32_t U_EXPORT2
+unumf_resultToString(const UFormattedNumber* uresult, UChar* buffer, int32_t bufferCapacity,
+                     UErrorCode* ec);
+
+
+/**
+ * Determines the start and end indices of the next occurrence of the given <em>field</em> in the
+ * output string. This allows you to determine the locations of, for example, the integer part,
+ * fraction part, or symbols.
+ *
+ * If a field occurs just once, calling this method will find that occurrence and return it. If a
+ * field occurs multiple times, this method may be called repeatedly with the following pattern:
+ *
+ * <pre>
+ * UFieldPosition ufpos = {UNUM_GROUPING_SEPARATOR_FIELD, 0, 0};
+ * while (unumf_resultNextFieldPosition(uresult, ufpos, &ec)) {
+ *   // do something with ufpos.
+ * }
+ * </pre>
+ *
+ * This method is useful if you know which field to query. If you want all available field position
+ * information, use unumf_resultGetAllFieldPositions().
+ *
+ * NOTE: All fields of the UFieldPosition must be initialized before calling this method.
+ *
+ * @param fieldPosition
+ *            Input+output variable. On input, the "field" property determines which field to look up,
+ *            and the "endIndex" property determines where to begin the search. On output, the
+ *            "beginIndex" field is set to the beginning of the first occurrence of the field after the
+ *            input "endIndex", and "endIndex" is set to the end of that occurrence of the field
+ *            (exclusive index). If a field position is not found, the FieldPosition is not changed and
+ *            the method returns FALSE.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT UBool U_EXPORT2
+unumf_resultNextFieldPosition(const UFormattedNumber* uresult, UFieldPosition* ufpos, UErrorCode* ec);
+
+
+/**
+ * Populates the given iterator with all fields in the formatted output string. This allows you to
+ * determine the locations of the integer part, fraction part, and sign.
+ *
+ * If you need information on only one field, use unumf_resultNextFieldPosition().
+ *
+ * @param uresult The object containing the formatted number.
+ * @param fpositer
+ *         A pointer to a UFieldPositionIterator created by {@link #ufieldpositer_open}. Iteration
+ *         information already present in the UFieldPositionIterator is deleted, and the iterator is reset
+ *         to apply to the fields in the formatted string created by this function call. The field values
+ *         and indexes returned by {@link #ufieldpositer_next} represent fields denoted by
+ *         the UNumberFormatFields enum. Fields are not returned in a guaranteed order. Fields cannot
+ *         overlap, but they may nest. For example, 1234 could format as "1,234" which might consist of a
+ *         grouping separator field for ',' and an integer field encompassing the entire string.
+ * @param ec Set if an error occurs.
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_resultGetAllFieldPositions(const UFormattedNumber* uresult, UFieldPositionIterator* ufpositer,
+                                 UErrorCode* ec);
+
+
+/**
+ * Releases the UNumberFormatter created by unumf_openForSkeletonAndLocale().
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uformatter An object created by unumf_openForSkeletonAndLocale().
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_close(UNumberFormatter* uformatter);
+
+
+/**
+ * Releases the UFormattedNumber created by unumf_openResult().
+ *
+ * NOTE: This is a C-compatible API; C++ users should build against numberformatter.h instead.
+ *
+ * @param uresult An object created by unumf_openResult().
+ * @draft ICU 62
+ */
+U_DRAFT void U_EXPORT2
+unumf_closeResult(UFormattedNumber* uresult);
+
+
+#if U_SHOW_CPLUSPLUS_API
+U_NAMESPACE_BEGIN
+
+/**
+ * \class LocalUNumberFormatterPointer
+ * "Smart pointer" class; closes a UNumberFormatter via unumf_close().
+ * For most methods see the LocalPointerBase base class.
+ *
+ * Usage:
+ * <pre>
+ * LocalUNumberFormatterPointer uformatter(unumf_openForSkeletonAndLocale(...));
+ * // no need to explicitly call unumf_close()
+ * </pre>
+ *
+ * @see LocalPointerBase
+ * @see LocalPointer
+ * @draft ICU 62
+ */
+U_DEFINE_LOCAL_OPEN_POINTER(LocalUNumberFormatterPointer, UNumberFormatter, unumf_close);
+
+/**
+ * \class LocalUNumberFormatterPointer
+ * "Smart pointer" class; closes a UFormattedNumber via unumf_closeResult().
+ * For most methods see the LocalPointerBase base class.
+ *
+ * Usage:
+ * <pre>
+ * LocalUFormattedNumberPointer uformatter(unumf_openResult(...));
+ * // no need to explicitly call unumf_closeResult()
+ * </pre>
+ *
+ * @see LocalPointerBase
+ * @see LocalPointer
+ * @draft ICU 62
+ */
+U_DEFINE_LOCAL_OPEN_POINTER(LocalUFormattedNumberPointer, UFormattedNumber, unumf_closeResult);
+
+U_NAMESPACE_END
+#endif // U_SHOW_CPLUSPLUS_API
+
+#endif  /* U_HIDE_DRAFT_API */
+
+#endif //__UNUMBERFORMATTER_H__
+#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/unicode/uspoof.h b/deps/icu-small/source/i18n/unicode/uspoof.h
index 9fcfcd3ede836c..781a88247fe4c5 100644
--- a/deps/icu-small/source/i18n/unicode/uspoof.h
+++ b/deps/icu-small/source/i18n/unicode/uspoof.h
@@ -477,7 +477,7 @@ typedef enum USpoofChecks {
       */
     USPOOF_CHAR_LIMIT               =  64,
 
-   /**
+    /**
      * Check that an identifier does not mix numbers from different numbering systems.
      * For more information, see UTS 39 section 5.3.
      *
@@ -485,6 +485,29 @@ typedef enum USpoofChecks {
      */
     USPOOF_MIXED_NUMBERS            = 128,
 
+#ifndef U_HIDE_DRAFT_API
+    /**
+     * Check that an identifier does not have a combining character following a character in which that
+     * combining character would be hidden; for example 'i' followed by a U+0307 combining dot.
+     *
+     * More specifically, the following characters are forbidden from preceding a U+0307:
+     * <ul>
+     * <li>Those with the Soft_Dotted Unicode property (which includes 'i' and 'j')</li>
+     * <li>Latin lowercase letter 'l'</li>
+     * <li>Dotless 'i' and 'j' ('ı' and 'ȷ', U+0131 and U+0237)</li>
+     * <li>Any character whose confusable prototype ends with such a character
+     * (Soft_Dotted, 'l', 'ı', or 'ȷ')</li>
+     * </ul>
+     * In addition, combining characters are allowed between the above characters and U+0307 except those
+     * with combining class 0 or combining class "Above" (230, same class as U+0307).
+     *
+     * This list and the number of combing characters considered by this check may grow over time.
+     *
+     * @draft ICU 62
+     */
+    USPOOF_HIDDEN_OVERLAY            = 256,
+#endif  /* U_HIDE_DRAFT_API */
+
    /**
      * Enable all spoof checks.
      *
diff --git a/deps/icu-small/source/i18n/upluralrules.cpp b/deps/icu-small/source/i18n/upluralrules.cpp
index 24e74e3ee223f5..bba6dfe3101ec3 100644
--- a/deps/icu-small/source/i18n/upluralrules.cpp
+++ b/deps/icu-small/source/i18n/upluralrules.cpp
@@ -17,9 +17,44 @@
 #include "unicode/unistr.h"
 #include "unicode/unum.h"
 #include "unicode/numfmt.h"
+#include "number_decimalquantity.h"
 
 U_NAMESPACE_USE
 
+namespace {
+
+/**
+ * Given a number and a format, returns the keyword of the first applicable
+ * rule for the PluralRules object.
+ * @param rules The plural rules.
+ * @param obj The numeric object for which the rule should be determined.
+ * @param fmt The NumberFormat specifying how the number will be formatted
+ *        (this can affect the plural form, e.g. "1 dollar" vs "1.0 dollars").
+ * @param status  Input/output parameter. If at entry this indicates a
+ *                failure status, the method returns immediately; otherwise
+ *                this is set to indicate the outcome of the call.
+ * @return The keyword of the selected rule. Undefined in the case of an error.
+ */
+UnicodeString select(const PluralRules &rules, const Formattable& obj, const NumberFormat& fmt, UErrorCode& status) {
+    if (U_SUCCESS(status)) {
+        const DecimalFormat *decFmt = dynamic_cast<const DecimalFormat *>(&fmt);
+        if (decFmt != NULL) {
+            number::impl::DecimalQuantity dq;
+            decFmt->formatToDecimalQuantity(obj, dq, status);
+            if (U_SUCCESS(status)) {
+                return rules.select(dq);
+            }
+        } else {
+            double number = obj.getDouble(status);
+            if (U_SUCCESS(status)) {
+                return rules.select(number);
+            }
+        }
+    }
+    return UnicodeString();
+}
+
+}  // namespace
 
 U_CAPI UPluralRules* U_EXPORT2
 uplrules_open(const char *locale, UErrorCode *status)
@@ -73,7 +108,7 @@ uplrules_selectWithFormat(const UPluralRules *uplrules,
         return 0;
     }
     Formattable obj(number);
-    UnicodeString result = plrules->select(obj, *nf, *status);
+    UnicodeString result = select(*plrules, obj, *nf, *status);
     return result.extract(keyword, capacity, *status);
 }
 
diff --git a/deps/icu-small/source/i18n/uspoof.cpp b/deps/icu-small/source/i18n/uspoof.cpp
index 019819b11cdde1..710adcd08daeaf 100644
--- a/deps/icu-small/source/i18n/uspoof.cpp
+++ b/deps/icu-small/source/i18n/uspoof.cpp
@@ -55,75 +55,96 @@ uspoof_cleanup(void) {
 }
 
 static void U_CALLCONV initializeStatics(UErrorCode &status) {
-    static const char *inclusionPat =
-        "['\\-.\\:\\u00B7\\u0375\\u058A\\u05F3\\u05F4\\u06FD\\u06FE\\u0F0B\\u200C\\u200D\\u2010\\u"
-        "2019\\u2027\\u30A0\\u30FB]";
-    gInclusionSet = new UnicodeSet(UnicodeString(inclusionPat, -1, US_INV), status);
+    static const char16_t *inclusionPat =
+        u"['\\-.\\:\\u00B7\\u0375\\u058A\\u05F3\\u05F4\\u06FD\\u06FE\\u0F0B\\u200C"
+        u"\\u200D\\u2010\\u2019\\u2027\\u30A0\\u30FB]";
+    gInclusionSet = new UnicodeSet(UnicodeString(inclusionPat), status);
+    if (gInclusionSet == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
     gInclusionSet->freeze();
 
-    // Note: data from http://unicode.org/Public/security/9.0.0/IdentifierStatus.txt
+    // Note: data from IdentifierStatus.txt & IdentifierType.txt
     // There is tooling to generate this constant in the unicodetools project:
     //      org.unicode.text.tools.RecommendedSetGenerator
     // It will print the Java and C++ code to the console for easy copy-paste into this file.
     // Note: concatenated string constants do not work with UNICODE_STRING_SIMPLE on all platforms.
-    static const char *recommendedPat =
-        "[0-9A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u0131\\u0134-\\u013E\\u0141-\\u014"
-        "8\\u014A-\\u017E\\u018F\\u01A0\\u01A1\\u01AF\\u01B0\\u01CD-\\u01DC\\u01DE-\\u01E3\\u01E"
-        "6-\\u01F0\\u01F4\\u01F5\\u01F8-\\u021B\\u021E\\u021F\\u0226-\\u0233\\u0259\\u02BB\\u02B"
-        "C\\u02EC\\u0300-\\u0304\\u0306-\\u030C\\u030F-\\u0311\\u0313\\u0314\\u031B\\u0323-\\u03"
-        "28\\u032D\\u032E\\u0330\\u0331\\u0335\\u0338\\u0339\\u0342\\u0345\\u037B-\\u037D\\u0386"
-        "\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03FC-\\u045F\\u048A-\\u0529\\u05"
-        "2E\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0586\\u05B4\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0"
-        "620-\\u063F\\u0641-\\u0655\\u0660-\\u0669\\u0670-\\u0672\\u0674\\u0679-\\u068D\\u068F-"
-        "\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE-\\u06FC\\u06FF\\u0750-\\u07B1\\u08A0-\\u08AC\\u08B2"
-        "\\u08B6-\\u08BD\\u0901-\\u094D\\u094F\\u0950\\u0956\\u0957\\u0960-\\u0963\\u0966-\\u096"
-        "F\\u0971-\\u0977\\u0979-\\u097F\\u0981-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u0"
-        "9A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u"
-        "09D7\\u09E0-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-"
-        "\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A35\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\"
-        "u0A4B-\\u0A4D\\u0A5C\\u0A66-\\u0A74\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A9"
-        "3-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0"
-        "ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\"
-        "u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B43\\u0B47"
-        "\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5F-\\u0B61\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83"
-        "\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3"
-        "\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0B"
-        "D0\\u0BD7\\u0BE6-\\u0BEF\\u0C01-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u"
-        "0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56"
-        "\\u0C60\\u0C61\\u0C66-\\u0C6F\\u0C80\\u0C82\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92"
-        "-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0"
-        "CD5\\u0CD6\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D02\\u0D03\\u0D05-\\u0D0C\\u0"
-        "D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57"
-        "\\u0D60\\u0D61\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D8E\\u0D91-\\u0D9"
-        "6\\u0D9A-\\u0DA5\\u0DA7-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0"
-        "DD4\\u0DD6\\u0DD8-\\u0DDE\\u0DF2\\u0E01-\\u0E32\\u0E34-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\"
-        "u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u"
-        "0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB2\\u0EB4-\\u0EB9\\u0EBB-\\u0EBD\\"
-        "u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDE\\u0EDF\\u0F00\\u0F20-\\u0F29"
-        "\\u0F35\\u0F37\\u0F3E-\\u0F42\\u0F44-\\u0F47\\u0F49-\\u0F4C\\u0F4E-\\u0F51\\u0F53-\\u0F"
-        "56\\u0F58-\\u0F5B\\u0F5D-\\u0F68\\u0F6A-\\u0F6C\\u0F71\\u0F72\\u0F74\\u0F7A-\\u0F80\\u0"
-        "F82-\\u0F84\\u0F86-\\u0F92\\u0F94-\\u0F97\\u0F99-\\u0F9C\\u0F9E-\\u0FA1\\u0FA3-\\u0FA6"
-        "\\u0FA8-\\u0FAB\\u0FAD-\\u0FB8\\u0FBA-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10"
-        "C7\\u10CD\\u10D0-\\u10F0\\u10F7-\\u10FA\\u10FD-\\u10FF\\u1200-\\u1248\\u124A-\\u124D\\u"
-        "1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2"
-        "-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1"
-        "315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u1780-\\u17A2\\u17A5-\\u17A7\\u17A9-"
-        "\\u17B3\\u17B6-\\u17CA\\u17D2\\u17D7\\u17DC\\u17E0-\\u17E9\\u1C80-\\u1C88\\u1E00-\\u1E9"
-        "9\\u1E9E\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1"
-        "F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F70\\u1F72\\u1F74\\u1F76\\u1F78\\u1F7A\\u1F"
-        "7C\\u1F80-\\u1FB4\\u1FB6-\\u1FBA\\u1FBC\\u1FC2-\\u1FC4\\u1FC6-\\u1FC8\\u1FCA\\u1FCC\\u1"
-        "FD0-\\u1FD2\\u1FD6-\\u1FDA\\u1FE0-\\u1FE2\\u1FE4-\\u1FEA\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-"
-        "\\u1FF8\\u1FFA\\u1FFC\\u2D27\\u2D2D\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0"
-        "-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3"
-        "005-\\u3007\\u3041-\\u3096\\u3099\\u309A\\u309D\\u309E\\u30A1-\\u30FA\\u30FC-\\u30FE\\u"
-        "3105-\\u312D\\u31A0-\\u31BA\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA660\\uA661\\uA674-\\uA67B"
-        "\\uA67F\\uA69F\\uA717-\\uA71F\\uA788\\uA78D\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7AE"
-        "\\uA7FA\\uA9E7-\\uA9FE\\uAA60-\\uAA76\\uAA7A-\\uAA7F\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB"
-        "11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAC00-\\uD7A3\\uFA0E\\uFA0F\\uFA11\\uFA13\\uF"
-        "A14\\uFA1F\\uFA21\\uFA23\\uFA24\\uFA27-\\uFA29\\U00020000-\\U0002A6D6\\U0002A700-\\U0"
-        "002B734\\U0002B740-\\U0002B81D\\U0002B820-\\U0002CEA1]";
-
-    gRecommendedSet = new UnicodeSet(UnicodeString(recommendedPat, -1, US_INV), status);
+    static const char16_t *recommendedPat =
+        u"[0-9A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u0131\\u0134-\\u013E"
+        u"\\u0141-\\u0148\\u014A-\\u017E\\u018F\\u01A0\\u01A1\\u01AF\\u01B0\\u01CD-"
+        u"\\u01DC\\u01DE-\\u01E3\\u01E6-\\u01F0\\u01F4\\u01F5\\u01F8-\\u021B\\u021E"
+        u"\\u021F\\u0226-\\u0233\\u0259\\u02BB\\u02BC\\u02EC\\u0300-\\u0304\\u0306-"
+        u"\\u030C\\u030F-\\u0311\\u0313\\u0314\\u031B\\u0323-\\u0328\\u032D\\u032E"
+        u"\\u0330\\u0331\\u0335\\u0338\\u0339\\u0342\\u0345\\u037B-\\u037D\\u0386"
+        u"\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03FC-\\u045F\\u048A-"
+        u"\\u0529\\u052E\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0586\\u0588\\u05B4"
+        u"\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u063F\\u0641-\\u0655\\u0660-\\u0669"
+        u"\\u0670-\\u0672\\u0674\\u0679-\\u068D\\u068F-\\u06D3\\u06D5\\u06E5\\u06E6"
+        u"\\u06EE-\\u06FC\\u06FF\\u0750-\\u07B1\\u08A0-\\u08AC\\u08B2\\u08B6-\\u08BD"
+        u"\\u0901-\\u094D\\u094F\\u0950\\u0956\\u0957\\u0960-\\u0963\\u0966-\\u096F"
+        u"\\u0971-\\u0977\\u0979-\\u097F\\u0981-\\u0983\\u0985-\\u098C\\u098F\\u0990"
+        u"\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7"
+        u"\\u09C8\\u09CB-\\u09CE\\u09D7\\u09E0-\\u09E3\\u09E6-\\u09F1\\u09FC\\u09FE"
+        u"\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30"
+        u"\\u0A32\\u0A35\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-"
+        u"\\u0A4D\\u0A5C\\u0A66-\\u0A74\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91"
+        u"\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5"
+        u"\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AFA-"
+        u"\\u0AFF\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-"
+        u"\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B43\\u0B47\\u0B48\\u0B4B-"
+        u"\\u0B4D\\u0B56\\u0B57\\u0B5F-\\u0B61\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83"
+        u"\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E"
+        u"\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-"
+        u"\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C01-\\u0C0C\\u0C0E-"
+        u"\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D-\\u0C44\\u0C46-"
+        u"\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C60\\u0C61\\u0C66-\\u0C6F\\u0C80"
+        u"\\u0C82\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3"
+        u"\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6"
+        u"\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D00\\u0D02\\u0D03\\u0D05-"
+        u"\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-"
+        u"\\u0D57\\u0D60\\u0D61\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-"
+        u"\\u0D8E\\u0D91-\\u0D96\\u0D9A-\\u0DA5\\u0DA7-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD"
+        u"\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDE\\u0DF2\\u0E01-"
+        u"\\u0E32\\u0E34-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84"
+        u"\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3"
+        u"\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB2\\u0EB4-\\u0EB9\\u0EBB-\\u0EBD"
+        u"\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDE\\u0EDF\\u0F00"
+        u"\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F3E-\\u0F42\\u0F44-\\u0F47\\u0F49-\\u0F4C"
+        u"\\u0F4E-\\u0F51\\u0F53-\\u0F56\\u0F58-\\u0F5B\\u0F5D-\\u0F68\\u0F6A-\\u0F6C"
+        u"\\u0F71\\u0F72\\u0F74\\u0F7A-\\u0F80\\u0F82-\\u0F84\\u0F86-\\u0F92\\u0F94-"
+        u"\\u0F97\\u0F99-\\u0F9C\\u0F9E-\\u0FA1\\u0FA3-\\u0FA6\\u0FA8-\\u0FAB\\u0FAD-"
+        u"\\u0FB8\\u0FBA-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10C7\\u10CD"
+        u"\\u10D0-\\u10F0\\u10F7-\\u10FA\\u10FD-\\u10FF\\u1200-\\u1248\\u124A-\\u124D"
+        u"\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-"
+        u"\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6"
+        u"\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F"
+        u"\\u1780-\\u17A2\\u17A5-\\u17A7\\u17A9-\\u17B3\\u17B6-\\u17CA\\u17D2\\u17D7"
+        u"\\u17DC\\u17E0-\\u17E9\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1E00-"
+        u"\\u1E99\\u1E9E\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45"
+        u"\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F70\\u1F72"
+        u"\\u1F74\\u1F76\\u1F78\\u1F7A\\u1F7C\\u1F80-\\u1FB4\\u1FB6-\\u1FBA\\u1FBC"
+        u"\\u1FC2-\\u1FC4\\u1FC6-\\u1FC8\\u1FCA\\u1FCC\\u1FD0-\\u1FD2\\u1FD6-\\u1FDA"
+        u"\\u1FE0-\\u1FE2\\u1FE4-\\u1FEA\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FF8\\u1FFA"
+        u"\\u1FFC\\u2D27\\u2D2D\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-"
+        u"\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-"
+        u"\\u2DDE\\u3005-\\u3007\\u3041-\\u3096\\u3099\\u309A\\u309D\\u309E\\u30A1-"
+        u"\\u30FA\\u30FC-\\u30FE\\u3105-\\u312F\\u31A0-\\u31BA\\u3400-\\u4DB5\\u4E00-"
+        u"\\u9FEF\\uA660\\uA661\\uA674-\\uA67B\\uA67F\\uA69F\\uA717-\\uA71F\\uA788"
+        u"\\uA78D\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7AE\\uA7AF\\uA7B8\\uA7B9"
+        u"\\uA7FA\\uA9E7-\\uA9FE\\uAA60-\\uAA76\\uAA7A-\\uAA7F\\uAB01-\\uAB06\\uAB09-"
+        u"\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAC00-\\uD7A3\\uFA0E"
+        u"\\uFA0F\\uFA11\\uFA13\\uFA14\\uFA1F\\uFA21\\uFA23\\uFA24\\uFA27-\\uFA29"
+        u"\\U0001133B\\U0001B002-\\U0001B11E\\U00020000-\\U0002A6D6\\U0002A700-"
+        u"\\U0002B734\\U0002B740-\\U0002B81D\\U0002B820-\\U0002CEA1\\U0002CEB0-"
+        u"\\U0002EBE0]";
+
+    gRecommendedSet = new UnicodeSet(UnicodeString(recommendedPat), status);
+    if (gRecommendedSet == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        delete gInclusionSet;
+        return;
+    }
     gRecommendedSet->freeze();
     gNfdNormalizer = Normalizer2::getNFDInstance(status);
     ucln_i18n_registerCleanup(UCLN_I18N_SPOOF, uspoof_cleanup);
@@ -140,12 +161,13 @@ uspoof_open(UErrorCode *status) {
         return NULL;
     }
     SpoofImpl *si = new SpoofImpl(*status);
-    if (U_SUCCESS(*status) && si == NULL) {
+    if (si == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
     }
     if (U_FAILURE(*status)) {
         delete si;
-        si = NULL;
+        return NULL;
     }
     return si->asUSpoofChecker();
 }
@@ -157,18 +179,38 @@ uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLeng
     if (U_FAILURE(*status)) {
         return NULL;
     }
+
+    if (data == NULL) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return NULL;
+    }
+
     umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
+    if (U_FAILURE(*status))
+    {
+        return NULL;
+    }
+
     SpoofData *sd = new SpoofData(data, length, *status);
-    SpoofImpl *si = new SpoofImpl(sd, *status);
+    if (sd == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+
     if (U_FAILURE(*status)) {
         delete sd;
-        delete si;
         return NULL;
     }
-    if (sd == NULL || si == NULL) {
+
+    SpoofImpl *si = new SpoofImpl(sd, *status);
+    if (si == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
-        delete sd;
-        delete si;
+        delete sd; // explicit delete as the destructor for si won't be called.
+        return NULL;
+    }
+
+    if (U_FAILURE(*status)) {
+        delete si; // no delete for sd, as the si destructor will delete it.
         return NULL;
     }
 
@@ -186,6 +228,10 @@ uspoof_clone(const USpoofChecker *sc, UErrorCode *status) {
         return NULL;
     }
     SpoofImpl *result = new SpoofImpl(*src, *status);   // copy constructor
+    if (result == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
     if (U_FAILURE(*status)) {
         delete result;
         result = NULL;
@@ -524,6 +570,13 @@ int32_t checkImpl(const SpoofImpl* This, const UnicodeString& id, CheckResult* c
         checkResult->fNumerics = numerics;  // UnicodeSet::operator=
     }
 
+    if (0 != (This->fChecks & USPOOF_HIDDEN_OVERLAY)) {
+        int32_t index = This->findHiddenOverlay(id, *status);
+        if (index != -1) {
+            result |= USPOOF_HIDDEN_OVERLAY;
+        }
+    }
+
 
     if (0 != (This->fChecks & USPOOF_CHAR_LIMIT)) {
         int32_t i;
diff --git a/deps/icu-small/source/i18n/uspoof_build.cpp b/deps/icu-small/source/i18n/uspoof_build.cpp
index 7d2440e5af65e8..7087c1ce596ced 100644
--- a/deps/icu-small/source/i18n/uspoof_build.cpp
+++ b/deps/icu-small/source/i18n/uspoof_build.cpp
@@ -71,8 +71,29 @@ uspoof_openFromSource(const char *confusables,  int32_t confusablesLen,
 
     // Set up a shell of a spoof detector, with empty data.
     SpoofData *newSpoofData = new SpoofData(*status);
+
+    if (newSpoofData == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+
+    if (U_FAILURE(*status)) {
+        delete newSpoofData;
+        return NULL;
+    }
     SpoofImpl *This = new SpoofImpl(newSpoofData, *status);
 
+    if (This == NULL) {
+        *status = U_MEMORY_ALLOCATION_ERROR;
+        delete newSpoofData; // explicit delete as the destructor for SpoofImpl won't be called.
+        return NULL;
+    }
+
+    if (U_FAILURE(*status)) {
+        delete This; // no delete for newSpoofData, as the SpoofImpl destructor will delete it.
+        return NULL;
+    }
+
     // Compile the binary data from the source (text) format.
     ConfusabledataBuilder::buildConfusableData(This, confusables, confusablesLen, errorType, pe, *status);
 
diff --git a/deps/icu-small/source/i18n/uspoof_conf.cpp b/deps/icu-small/source/i18n/uspoof_conf.cpp
index 3a061d9dfcffe1..672b3e0a6c8023 100644
--- a/deps/icu-small/source/i18n/uspoof_conf.cpp
+++ b/deps/icu-small/source/i18n/uspoof_conf.cpp
@@ -76,6 +76,10 @@ SPUString::~SPUString() {
 
 SPUStringPool::SPUStringPool(UErrorCode &status) : fVec(NULL), fHash(NULL) {
     fVec = new UVector(status);
+    if (fVec == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
     fHash = uhash_open(uhash_hashUnicodeString,           // key hash function
                        uhash_compareUnicodeString,        // Key Comparator
                        NULL,                              // Value Comparator
@@ -136,6 +140,10 @@ SPUString *SPUStringPool::addString(UnicodeString *src, UErrorCode &status) {
         delete src;
     } else {
         hashedString = new SPUString(src);
+        if (hashedString == NULL) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+            return NULL;
+        }
         uhash_put(fHash, src, hashedString, &status);
         fVec->addElement(hashedString, status);
     }
@@ -160,11 +168,32 @@ ConfusabledataBuilder::ConfusabledataBuilder(SpoofImpl *spImpl, UErrorCode &stat
     if (U_FAILURE(status)) {
         return;
     }
-    fTable    = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
-    fKeySet     = new UnicodeSet();
-    fKeyVec     = new UVector(status);
-    fValueVec   = new UVector(status);
+
+    fTable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
+
+    fKeySet = new UnicodeSet();
+    if (fKeySet == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
+    fKeyVec = new UVector(status);
+    if (fKeyVec == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
+    fValueVec = new UVector(status);
+    if (fValueVec == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
+
     stringPool = new SPUStringPool(status);
+    if (stringPool == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return;
+    }
 }
 
 
diff --git a/deps/icu-small/source/i18n/uspoof_impl.cpp b/deps/icu-small/source/i18n/uspoof_impl.cpp
index 0ca85c00a98a8d..c1034c2e53f6e9 100644
--- a/deps/icu-small/source/i18n/uspoof_impl.cpp
+++ b/deps/icu-small/source/i18n/uspoof_impl.cpp
@@ -377,6 +377,43 @@ URestrictionLevel SpoofImpl::getRestrictionLevel(const UnicodeString& input, UEr
     return USPOOF_MINIMALLY_RESTRICTIVE;
 }
 
+int32_t SpoofImpl::findHiddenOverlay(const UnicodeString& input, UErrorCode&) const {
+    bool sawLeadCharacter = false;
+    for (int32_t i=0; i<input.length();) {
+        UChar32 cp = input.char32At(i);
+        if (sawLeadCharacter && cp == 0x0307) {
+            return i;
+        }
+        uint8_t combiningClass = u_getCombiningClass(cp);
+        // Skip over characters except for those with combining class 0 (non-combining characters) or with
+        // combining class 230 (same class as U+0307)
+        U_ASSERT(u_getCombiningClass(0x0307) == 230);
+        if (combiningClass == 0 || combiningClass == 230) {
+            sawLeadCharacter = isIllegalCombiningDotLeadCharacter(cp);
+        }
+        i += U16_LENGTH(cp);
+    }
+    return -1;
+}
+
+static inline bool isIllegalCombiningDotLeadCharacterNoLookup(UChar32 cp) {
+    return cp == u'i' || cp == u'j' || cp == u'ı' || cp == u'ȷ' || cp == u'l' ||
+           u_hasBinaryProperty(cp, UCHAR_SOFT_DOTTED);
+}
+
+bool SpoofImpl::isIllegalCombiningDotLeadCharacter(UChar32 cp) const {
+    if (isIllegalCombiningDotLeadCharacterNoLookup(cp)) {
+        return true;
+    }
+    UnicodeString skelStr;
+    fSpoofData->confusableLookup(cp, skelStr);
+    UChar32 finalCp = skelStr.char32At(skelStr.moveIndex32(skelStr.length(), -1));
+    if (finalCp != cp && isIllegalCombiningDotLeadCharacterNoLookup(finalCp)) {
+        return true;
+    }
+    return false;
+}
+
 
 
 // Convert a text format hex number.  Utility function used by builder code.  Static.
@@ -532,24 +569,25 @@ uspoof_cleanupDefaultData(void) {
     if (gDefaultSpoofData) {
         // Will delete, assuming all user-level spoof checkers were closed.
         gDefaultSpoofData->removeReference();
-        gDefaultSpoofData = NULL;
+        gDefaultSpoofData = nullptr;
         gSpoofInitDefaultOnce.reset();
     }
     return TRUE;
 }
 
 static void U_CALLCONV uspoof_loadDefaultData(UErrorCode& status) {
-    UDataMemory *udm = udata_openChoice(NULL, "cfu", "confusables",
+    UDataMemory *udm = udata_openChoice(nullptr, "cfu", "confusables",
                                         spoofDataIsAcceptable,
-                                        NULL,       // context, would receive dataVersion if supplied.
+                                        nullptr,       // context, would receive dataVersion if supplied.
                                         &status);
     if (U_FAILURE(status)) { return; }
     gDefaultSpoofData = new SpoofData(udm, status);
     if (U_FAILURE(status)) {
         delete gDefaultSpoofData;
+        gDefaultSpoofData = nullptr;
         return;
     }
-    if (gDefaultSpoofData == NULL) {
+    if (gDefaultSpoofData == nullptr) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
@@ -590,6 +628,10 @@ SpoofData::SpoofData(const void *data, int32_t length, UErrorCode &status)
         status = U_INVALID_FORMAT_ERROR;
         return;
     }
+    if (data == NULL) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
     void *ncData = const_cast<void *>(data);
     fRawData = static_cast<SpoofDataHeader *>(ncData);
     if (length < fRawData->fLength) {
diff --git a/deps/icu-small/source/i18n/uspoof_impl.h b/deps/icu-small/source/i18n/uspoof_impl.h
index 1184b8d9060662..470a31f2c979bc 100644
--- a/deps/icu-small/source/i18n/uspoof_impl.h
+++ b/deps/icu-small/source/i18n/uspoof_impl.h
@@ -83,6 +83,9 @@ class SpoofImpl : public UObject  {
     void getNumerics(const UnicodeString& input, UnicodeSet& result, UErrorCode& status) const;
     URestrictionLevel getRestrictionLevel(const UnicodeString& input, UErrorCode& status) const;
 
+    int32_t findHiddenOverlay(const UnicodeString& input, UErrorCode& status) const;
+    bool isIllegalCombiningDotLeadCharacter(UChar32 cp) const;
+
     /** parse a hex number.  Untility used by the builders.   */
     static UChar32 ScanHex(const UChar *s, int32_t start, int32_t limit, UErrorCode &status);
 
diff --git a/deps/icu-small/source/i18n/valueformatter.cpp b/deps/icu-small/source/i18n/valueformatter.cpp
deleted file mode 100644
index e769f369d48609..00000000000000
--- a/deps/icu-small/source/i18n/valueformatter.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines Corporation and
-* others. All Rights Reserved.
-*******************************************************************************
-*/
-
-#include "unicode/plurrule.h"
-#include "unicode/unistr.h"
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "digitformatter.h"
-#include "digitgrouping.h"
-#include "digitinterval.h"
-#include "digitlst.h"
-#include "precision.h"
-#include "plurrule_impl.h"
-#include "smallintformatter.h"
-#include "uassert.h"
-#include "valueformatter.h"
-#include "visibledigits.h"
-
-U_NAMESPACE_BEGIN
-
-ValueFormatter::~ValueFormatter() {}
-
-VisibleDigitsWithExponent &
-ValueFormatter::toVisibleDigitsWithExponent(
-        int64_t value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    switch (fType) {
-    case kFixedDecimal:
-        return fFixedPrecision->initVisibleDigitsWithExponent(
-                value, digits, status);
-        break;
-    case kScientificNotation:
-        return fScientificPrecision->initVisibleDigitsWithExponent(
-                value, digits, status);
-        break;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return digits;
-}
-
-VisibleDigitsWithExponent &
-ValueFormatter::toVisibleDigitsWithExponent(
-        DigitList &value,
-        VisibleDigitsWithExponent &digits,
-        UErrorCode &status) const {
-    switch (fType) {
-    case kFixedDecimal:
-        return fFixedPrecision->initVisibleDigitsWithExponent(
-                value, digits, status);
-        break;
-    case kScientificNotation:
-        return fScientificPrecision->initVisibleDigitsWithExponent(
-                value, digits, status);
-        break;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return digits;
-}
-
-static UBool isNoGrouping(
-        const DigitGrouping &grouping,
-        int32_t value,
-        const FixedPrecision &precision) {
-    IntDigitCountRange range(
-            precision.fMin.getIntDigitCount(),
-            precision.fMax.getIntDigitCount());
-    return grouping.isNoGrouping(value, range);
-}
-
-UBool
-ValueFormatter::isFastFormattable(int32_t value) const {
-    switch (fType) {
-    case kFixedDecimal:
-        {
-            if (value == INT32_MIN) {
-                return FALSE;
-            }
-            if (value < 0) {
-                value = -value;
-            }
-            return fFixedPrecision->isFastFormattable() && fFixedOptions->isFastFormattable() && isNoGrouping(*fGrouping, value, *fFixedPrecision);
-        }
-    case kScientificNotation:
-        return FALSE;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return FALSE;
-}
-
-DigitList &
-ValueFormatter::round(DigitList &value, UErrorCode &status) const {
-    if (value.isNaN() || value.isInfinite()) {
-        return value;
-    }
-    switch (fType) {
-    case kFixedDecimal:
-        return fFixedPrecision->round(value, 0, status);
-    case kScientificNotation:
-        return fScientificPrecision->round(value, status);
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return value;
-}
-
-UnicodeString &
-ValueFormatter::formatInt32(
-        int32_t value,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    switch (fType) {
-    case kFixedDecimal:
-        {
-            IntDigitCountRange range(
-                    fFixedPrecision->fMin.getIntDigitCount(),
-                    fFixedPrecision->fMax.getIntDigitCount());
-            return fDigitFormatter->formatPositiveInt32(
-                    value,
-                    range,
-                    handler,
-                    appendTo);
-        }
-        break;
-    case kScientificNotation:
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return appendTo;
-}
-
-UnicodeString &
-ValueFormatter::format(
-        const VisibleDigitsWithExponent &value,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const {
-    switch (fType) {
-    case kFixedDecimal:
-        return fDigitFormatter->format(
-                value.getMantissa(),
-                *fGrouping,
-                *fFixedOptions,
-                handler,
-                appendTo);
-        break;
-    case kScientificNotation:
-        return fDigitFormatter->format(
-                value,
-                *fScientificOptions,
-                handler,
-                appendTo);
-        break;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return appendTo;
-}
-
-int32_t
-ValueFormatter::countChar32(const VisibleDigitsWithExponent &value) const {
-    switch (fType) {
-    case kFixedDecimal:
-        return fDigitFormatter->countChar32(
-                value.getMantissa(),
-                *fGrouping,
-                *fFixedOptions);
-        break;
-    case kScientificNotation:
-        return fDigitFormatter->countChar32(
-                value,
-                *fScientificOptions);
-        break;
-    default:
-        U_ASSERT(FALSE);
-        break;
-    }
-    return 0;
-}
-
-void
-ValueFormatter::prepareFixedDecimalFormatting(
-        const DigitFormatter &formatter,
-        const DigitGrouping &grouping,
-        const FixedPrecision &precision,
-        const DigitFormatterOptions &options) {
-    fType = kFixedDecimal;
-    fDigitFormatter = &formatter;
-    fGrouping = &grouping;
-    fFixedPrecision = &precision;
-    fFixedOptions = &options;
-}
-
-void
-ValueFormatter::prepareScientificFormatting(
-        const DigitFormatter &formatter,
-        const ScientificPrecision &precision,
-        const SciFormatterOptions &options) {
-    fType = kScientificNotation;
-    fDigitFormatter = &formatter;
-    fScientificPrecision = &precision;
-    fScientificOptions = &options;
-}
-
-U_NAMESPACE_END
-
-#endif /* !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/valueformatter.h b/deps/icu-small/source/i18n/valueformatter.h
deleted file mode 100644
index 836a05b17c5209..00000000000000
--- a/deps/icu-small/source/i18n/valueformatter.h
+++ /dev/null
@@ -1,161 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2015, International Business Machines Corporation and         *
-* others. All Rights Reserved.                                                *
-*******************************************************************************
-*/
-
-#ifndef VALUEFORMATTER_H
-#define VALUEFORMATTER_H
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/uobject.h"
-#include "unicode/utypes.h"
-
-
-
-U_NAMESPACE_BEGIN
-
-class UnicodeString;
-class DigitList;
-class FieldPositionHandler;
-class DigitGrouping;
-class PluralRules;
-class FixedPrecision;
-class DigitFormatter;
-class DigitFormatterOptions;
-class ScientificPrecision;
-class SciFormatterOptions;
-class FixedDecimal;
-class VisibleDigitsWithExponent;
-
-
-/**
- * A closure around rounding and formatting a value. As these instances are
- * designed to be short lived (they only exist while formatting a value), they
- * do not own their own attributes. Rather the caller maintains ownership of
- * all attributes. A caller first calls a prepareXXX method on an instance
- * to share its data before using that instance. Using an
- * instance without first calling a prepareXXX method results in an
- * assertion error and a program crash.
- */
-class U_I18N_API ValueFormatter : public UObject {
-public:
-    ValueFormatter() : fType(kFormatTypeCount) {
-    }
-
-    virtual ~ValueFormatter();
-
-    /**
-     * This function is here only to support the protected round() method
-     * in DecimalFormat. It serves no ther purpose than that.
-     *
-     * @param value this value is rounded in place.
-     * @param status any error returned here.
-     */
-    DigitList &round(DigitList &value, UErrorCode &status) const;
-
-    /**
-     * Returns TRUE if the absolute value of value can be fast formatted
-     * using ValueFormatter::formatInt32.
-     */
-    UBool isFastFormattable(int32_t value) const;
-
-    /**
-     * Converts value to a VisibleDigitsWithExponent.
-     * Result may be fixed point or scientific.
-     */
-    VisibleDigitsWithExponent &toVisibleDigitsWithExponent(
-            int64_t value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * Converts value to a VisibleDigitsWithExponent.
-     * Result may be fixed point or scientific.
-     */
-    VisibleDigitsWithExponent &toVisibleDigitsWithExponent(
-            DigitList &value,
-            VisibleDigitsWithExponent &digits,
-            UErrorCode &status) const;
-
-    /**
-     * formats positiveValue and appends to appendTo. Returns appendTo.
-     * @param positiveValue If negative, no negative sign is formatted.
-     * @param handler stores the field positions
-     * @param appendTo formatted value appended here.
-     */
-    UnicodeString &format(
-        const VisibleDigitsWithExponent &positiveValue,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-
-    /**
-     * formats positiveValue and appends to appendTo. Returns appendTo.
-     * value must be positive. Calling formatInt32 to format a value when
-     * isFastFormattable indicates that the value cannot be fast formatted
-     * results in undefined behavior.
-     */
-    UnicodeString &formatInt32(
-        int32_t positiveValue,
-        FieldPositionHandler &handler,
-        UnicodeString &appendTo) const;
-
-    /**
-     * Returns the number of code points needed to format.
-     * @param positiveValue if negative, the negative sign is not included
-     *   in count.
-     */
-    int32_t countChar32(
-            const VisibleDigitsWithExponent &positiveValue) const;
-
-    /**
-     * Prepares this instance for fixed decimal formatting.
-     */
-    void prepareFixedDecimalFormatting(
-        const DigitFormatter &formatter,
-        const DigitGrouping &grouping,
-        const FixedPrecision &precision,
-        const DigitFormatterOptions &options);
-
-    /**
-     * Prepares this instance for scientific formatting.
-     */
-    void prepareScientificFormatting(
-        const DigitFormatter &formatter,
-        const ScientificPrecision &precision,
-        const SciFormatterOptions &options);
-
-private:
-    ValueFormatter(const ValueFormatter &);
-    ValueFormatter &operator=(const ValueFormatter &);
-    enum FormatType {
-        kFixedDecimal,
-        kScientificNotation,
-        kFormatTypeCount
-    };
-
-    FormatType fType;
-
-    // for fixed decimal and scientific formatting
-    const DigitFormatter *fDigitFormatter;
-
-    // for fixed decimal formatting
-    const FixedPrecision *fFixedPrecision;
-    const DigitFormatterOptions *fFixedOptions;
-    const DigitGrouping *fGrouping;
-
-    // for scientific formatting
-    const ScientificPrecision *fScientificPrecision;
-    const SciFormatterOptions *fScientificOptions;
-};
-
-U_NAMESPACE_END
-
-#endif /* !UCONFIG_NO_FORMATTING */
-
-#endif /* VALUEFORMATTER_H */
diff --git a/deps/icu-small/source/i18n/visibledigits.cpp b/deps/icu-small/source/i18n/visibledigits.cpp
deleted file mode 100644
index 03cfc68d255380..00000000000000
--- a/deps/icu-small/source/i18n/visibledigits.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- * Copyright (C) 2016, International Business Machines
- * Corporation and others.  All Rights Reserved.
- *
- * file name: visibledigits.cpp
- */
-
-#include <math.h>
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "cstring.h"
-#include "decNumber.h"
-#include "digitlst.h"
-#include "uassert.h"
-#include "visibledigits.h"
-
-static const int32_t kNegative = 1;
-static const int32_t kInfinite = 2;
-static const int32_t kNaN = 4;
-
-U_NAMESPACE_BEGIN
-
-void VisibleDigits::setNegative() {
-    fFlags |= kNegative;
-}
-
-void VisibleDigits::setNaN() {
-    fFlags |= kNaN;
-}
-
-void VisibleDigits::setInfinite() {
-    fFlags |= kInfinite;
-}
-
-void VisibleDigits::clear() {
-    fInterval.clear();
-    fDigits.clear();
-    fExponent = 0;
-    fFlags = 0;
-    fAbsIntValue = 0LL;
-    fAbsIntValueSet = FALSE;
-    fAbsDoubleValue = 0.0;
-    fAbsDoubleValueSet = FALSE;
-}
-
-UBool VisibleDigits::isNegative() const {
-    return (fFlags & kNegative);
-}
-
-UBool VisibleDigits::isNaN() const {
-    return (fFlags & kNaN);
-}
-
-UBool VisibleDigits::isInfinite() const {
-    return (fFlags & kInfinite);
-}
-
-int32_t VisibleDigits::getDigitByExponent(int32_t digitPos) const {
-    if (digitPos < fExponent || digitPos >= fExponent + fDigits.length()) {
-        return 0;
-    }
-    const char *ptr = fDigits.data();
-    return ptr[digitPos - fExponent];
-}
-
-UBool VisibleDigits::isOverMaxDigits() const {
-    return (fExponent + fDigits.length() > fInterval.getMostSignificantExclusive());
-}
-
-UBool VisibleDigits::isNaNOrInfinity() const {
-    return (fFlags & (kInfinite | kNaN)) != 0;
-}
-
-double VisibleDigits::computeAbsDoubleValue() const {
-    // Take care of NaN and infinity
-    if (isNaN()) {
-        return uprv_getNaN();
-    }
-    if (isInfinite()) {
-        return uprv_getInfinity();
-    }
-
-    // stack allocate a decNumber to hold MAX_DBL_DIGITS+3 significant digits
-    struct {
-        decNumber  decNum;
-        char       digits[MAX_DBL_DIGITS+3];
-    } decNumberWithStorage;
-    decNumber *numberPtr = &decNumberWithStorage.decNum;
-
-    int32_t mostSig = fInterval.getMostSignificantExclusive();
-    int32_t mostSigNonZero = fExponent + fDigits.length();
-    int32_t end = mostSig > mostSigNonZero ? mostSigNonZero : mostSig;
-    int32_t leastSig = fInterval.getLeastSignificantInclusive();
-    int32_t start = leastSig > fExponent ? leastSig : fExponent;
-    if (end <= start) {
-        return 0.0;
-    }
-    if (start < end - (MAX_DBL_DIGITS+3)) {
-        start = end - (MAX_DBL_DIGITS+3);
-    }
-    uint8_t *pos = numberPtr->lsu;
-    const char *src = &(fDigits.data()[start - fExponent]);
-    for (int32_t i = start; i < end; ++i) {
-        *pos++ = (uint8_t) (*src++);
-    }
-    numberPtr->exponent = start;
-    numberPtr->bits = 0;
-    numberPtr->digits = end - start;
-    char str[MAX_DBL_DIGITS+18];
-    uprv_decNumberToString(numberPtr, str);
-    U_ASSERT(uprv_strlen(str) < MAX_DBL_DIGITS+18);
-    char *unused = NULL;
-    return DigitList::decimalStrToDouble(str, &unused);
-}
-
-void VisibleDigits::getFixedDecimal(
-    double &source, int64_t &intValue, int64_t &f, int64_t &t, int32_t &v, UBool &hasIntValue) const {
-    source = 0.0;
-    intValue = 0;
-    f = 0;
-    t = 0;
-    v = 0;
-    hasIntValue = FALSE;
-    if (isNaNOrInfinity()) {
-        return;
-    }
-
-    // source
-    if (fAbsDoubleValueSet) {
-        source = fAbsDoubleValue;
-    } else {
-        source = computeAbsDoubleValue();
-    }
-
-    // visible decimal digits
-    v = fInterval.getFracDigitCount();
-
-    // intValue
-
-    // If we initialized from an int64 just use that instead of
-    // calculating
-    if (fAbsIntValueSet) {
-        intValue = fAbsIntValue;
-    } else {
-        int32_t startPos = fInterval.getMostSignificantExclusive();
-        if (startPos > 18) {
-            startPos = 18;
-        }
-        // process the integer digits
-        for (int32_t i = startPos - 1; i >= 0; --i) {
-            intValue = intValue * 10LL + getDigitByExponent(i);
-        }
-        if (intValue == 0LL && startPos > 0) {
-            intValue = 100000000000000000LL;
-        }
-    }
-
-    // f (decimal digits)
-    // skip over any leading 0's in fraction digits.
-    int32_t idx = -1;
-    for (; idx >= -v && getDigitByExponent(idx) == 0; --idx)
-      ;
-
-    // Only process up to first 18 non zero fraction digits for decimalDigits
-    // since that is all we can fit into an int64.
-    for (int32_t i = idx; i >= -v && i > idx - 18; --i) {
-        f = f * 10LL + getDigitByExponent(i);
-    }
-
-    // If we have no decimal digits, we don't have an integer value
-    hasIntValue = (f == 0LL);
-
-    // t (decimal digits without trailing zeros)
-   t = f;
-    while (t > 0 && t % 10LL == 0) {
-        t /= 10;
-    }
-}
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
diff --git a/deps/icu-small/source/i18n/visibledigits.h b/deps/icu-small/source/i18n/visibledigits.h
deleted file mode 100644
index 03c8013e393374..00000000000000
--- a/deps/icu-small/source/i18n/visibledigits.h
+++ /dev/null
@@ -1,162 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************* * Copyright (C) 2015, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* visibledigits.h
-*
-* created on: 2015jun20
-* created by: Travis Keep
-*/
-
-#ifndef __VISIBLEDIGITS_H__
-#define __VISIBLEDIGITS_H__
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_FORMATTING
-
-#include "unicode/uobject.h"
-
-#include "charstr.h"
-#include "digitinterval.h"
-
-U_NAMESPACE_BEGIN
-
-class DigitList;
-
-/**
- * VisibleDigits represents the digits visible for formatting.
- * Once initialized using a FixedPrecision instance, VisibleDigits instances
- * remain unchanged until they are initialized again. A VisibleDigits with
- * a numeric value equal to 3.0 could be "3", "3.0", "3.00" or even "003.0"
- * depending on settings of the FixedPrecision instance used to initialize it.
- */
-class U_I18N_API VisibleDigits : public UMemory {
-public:
-    VisibleDigits() : fExponent(0), fFlags(0), fAbsIntValue(0), fAbsIntValueSet(FALSE), fAbsDoubleValue(0.0), fAbsDoubleValueSet(FALSE) { }
-
-    UBool isNegative() const;
-    UBool isNaN() const;
-    UBool isInfinite() const;
-    UBool isNaNOrInfinity() const;
-
-    /**
-     * Gets the digit at particular exponent, if number is 987.6, then
-     * getDigit(2) == 9 and gitDigit(0) == 7 and gitDigit(-1) == 6.
-     * If isNaN() or isInfinity() return TRUE, then the result of this
-     * function is undefined.
-     */
-    int32_t getDigitByExponent(int32_t digitPos) const;
-
-    /**
-     * Returns the digit interval which indicates the leftmost and rightmost
-     * position of this instance.
-     * If isNaN() or isInfinity() return TRUE, then the result of this
-     * function is undefined.
-     */
-    const DigitInterval &getInterval() const { return fInterval; }
-
-    /**
-     * Gets the parameters needed to create a FixedDecimal.
-     */
-    void getFixedDecimal(double &source, int64_t &intValue, int64_t &f, int64_t &t, int32_t &v, UBool &hasIntValue) const;
-
-
-private:
-    /**
-     * The digits, least significant first. Both the least and most
-     * significant digit in this list are non-zero; however, digits in the
-     * middle may be zero. This field contains values between (char) 0, and
-     * (char) 9 inclusive.
-     */
-    CharString fDigits;
-
-    /**
-     * The range of displayable digits. This field is needed to account for
-     * any leading and trailing zeros which are not stored in fDigits.
-     */
-    DigitInterval fInterval;
-
-    /**
-     * The exponent value of the least significant digit in fDigits. For
-     * example, fExponent = 2 and fDigits = {7, 8, 5} represents 58700.
-     */
-    int32_t fExponent;
-
-    /**
-     * Contains flags such as NaN, Inf, and negative.
-     */
-    int32_t fFlags;
-
-    /**
-     * Contains the absolute value of the digits left of the decimal place
-     * if fAbsIntValueSet is TRUE
-     */
-    int64_t fAbsIntValue;
-
-    /**
-     * Indicates whether or not fAbsIntValue is set.
-     */
-    UBool fAbsIntValueSet;
-
-    /**
-     * Contains the absolute value of the value this instance represents
-     * if fAbsDoubleValueSet is TRUE
-     */
-    double fAbsDoubleValue;
-
-    /**
-     * Indicates whether or not fAbsDoubleValue is set.
-     */
-    UBool fAbsDoubleValueSet;
-
-    void setNegative();
-    void setNaN();
-    void setInfinite();
-    void clear();
-    double computeAbsDoubleValue() const;
-    UBool isOverMaxDigits() const;
-
-    VisibleDigits(const VisibleDigits &);
-    VisibleDigits &operator=(const VisibleDigits &);
-
-    friend class FixedPrecision;
-    friend class VisibleDigitsWithExponent;
-};
-
-/**
- * A VisibleDigits with a possible exponent.
- */
-class U_I18N_API VisibleDigitsWithExponent : public UMemory {
-public:
-    VisibleDigitsWithExponent() : fHasExponent(FALSE) { }
-    const VisibleDigits &getMantissa() const { return fMantissa; }
-    const VisibleDigits *getExponent() const {
-        return fHasExponent ? &fExponent : NULL;
-    }
-    void clear() {
-        fMantissa.clear();
-        fExponent.clear();
-        fHasExponent = FALSE;
-    }
-    UBool isNegative() const { return fMantissa.isNegative(); }
-    UBool isNaN() const { return fMantissa.isNaN(); }
-    UBool isInfinite() const { return fMantissa.isInfinite(); }
-private:
-    VisibleDigitsWithExponent(const VisibleDigitsWithExponent &);
-    VisibleDigitsWithExponent &operator=(
-        const VisibleDigitsWithExponent &);
-    VisibleDigits fMantissa;
-    VisibleDigits fExponent;
-    UBool fHasExponent;
-
-    friend class ScientificPrecision;
-    friend class FixedPrecision;
-};
-
-
-U_NAMESPACE_END
-#endif /* #if !UCONFIG_NO_FORMATTING */
-#endif  // __VISIBLEDIGITS_H__
diff --git a/deps/icu-small/source/i18n/windtfmt.cpp b/deps/icu-small/source/i18n/windtfmt.cpp
index e8e32abd3ff477..983fd46c122e6f 100644
--- a/deps/icu-small/source/i18n/windtfmt.cpp
+++ b/deps/icu-small/source/i18n/windtfmt.cpp
@@ -385,7 +385,8 @@ UnicodeString Win32DateFormat::setTimeZoneInfo(TIME_ZONE_INFORMATION *tzi, const
             for (int z = 0; z < ec; z += 1) {
                 UnicodeString equiv = TimeZone::getEquivalentID(icuid, z);
 
-                if (found = uprv_getWindowsTimeZoneInfo(tzi, equiv.getBuffer(), equiv.length())) {
+                found = uprv_getWindowsTimeZoneInfo(tzi, equiv.getBuffer(), equiv.length());
+                if (found) {
                     break;
                 }
             }
diff --git a/deps/icu-small/source/i18n/zonemeta.cpp b/deps/icu-small/source/i18n/zonemeta.cpp
index c386b0cae5e2ca..02562048a525da 100644
--- a/deps/icu-small/source/i18n/zonemeta.cpp
+++ b/deps/icu-small/source/i18n/zonemeta.cpp
@@ -690,6 +690,7 @@ ZoneMeta::createMetazoneMappings(const UnicodeString &tzid) {
                     mzMappings = new UVector(deleteOlsonToMetaMappingEntry, NULL, status);
                     if (U_FAILURE(status)) {
                         delete mzMappings;
+                        mzMappings = NULL;
                         uprv_free(entry);
                         break;
                     }
diff --git a/deps/icu-small/source/tools/toolutil/swapimpl.cpp b/deps/icu-small/source/tools/toolutil/swapimpl.cpp
index a64a6a1703f2c7..f3f333a005eb43 100644
--- a/deps/icu-small/source/tools/toolutil/swapimpl.cpp
+++ b/deps/icu-small/source/tools/toolutil/swapimpl.cpp
@@ -336,7 +336,7 @@ ucase_swap(const UDataSwapper *ds,
         ((pInfo->formatVersion[0]==1 &&
           pInfo->formatVersion[2]==UTRIE_SHIFT &&
           pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT) ||
-         pInfo->formatVersion[0]==2 || pInfo->formatVersion[0]==3)
+         2<=pInfo->formatVersion[0] || pInfo->formatVersion[0]<=4)
     )) {
         udata_printError(ds, "ucase_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as case mapping data\n",
                          pInfo->dataFormat[0], pInfo->dataFormat[1],
diff --git a/deps/icu-small/source/tools/toolutil/udbgutil.cpp b/deps/icu-small/source/tools/toolutil/udbgutil.cpp
index 446e11aaf9084f..dcc80ebe069519 100644
--- a/deps/icu-small/source/tools/toolutil/udbgutil.cpp
+++ b/deps/icu-small/source/tools/toolutil/udbgutil.cpp
@@ -554,7 +554,6 @@ static const USystemParams systemParams[] = {
 #endif
   { "uconfig.internal_digitlist", paramInteger, "b", 1}, /* always 1 */
   { "uconfig.have_parseallinput", paramInteger, "b", UCONFIG_HAVE_PARSEALLINPUT},
-  { "uconfig.format_fastpaths_49",paramInteger, "b", UCONFIG_FORMAT_FASTPATHS_49},
 
 
 };

From 25fef3d8d4682456b2db1571e3657d9144275dd7 Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Mon, 9 Jul 2018 01:44:27 +0300
Subject: [PATCH 040/116] workers: fix invalid exit code in parent upon
 uncaught exception

Now worker.on('exit') reports correct exit code (1) if worker has exited
with uncaught exception.

Fixes: https://github.com/nodejs/node/issues/21707

PR-URL: https://github.com/nodejs/node/pull/21713
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 lib/internal/worker.js                        |   3 +
 test/parallel/test-worker-exit-code.js        | 130 ++++++++++++++++++
 .../test-worker-uncaught-exception-async.js   |   4 +
 .../test-worker-uncaught-exception.js         |   4 +
 4 files changed, 141 insertions(+)
 create mode 100644 test/parallel/test-worker-exit-code.js

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index bcc864b5b8b330..83389d204d285f 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -454,6 +454,9 @@ function setupChild(evalScript) {
     debug(`[${threadId}] fatal exception caught = ${caught}`);
 
     if (!caught) {
+      // set correct code (uncaughtException) for [kOnExit](code) handler
+      process.exitCode = 1;
+
       let serialized;
       try {
         serialized = serializeError(error);
diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
new file mode 100644
index 00000000000000..bb47e1cece7a62
--- /dev/null
+++ b/test/parallel/test-worker-exit-code.js
@@ -0,0 +1,130 @@
+// Flags: --experimental-worker
+'use strict';
+const common = require('../common');
+
+// This test checks that Worker has correct exit codes on parent side
+// in multiple situations.
+
+const assert = require('assert');
+const worker = require('worker_threads');
+const { Worker, isMainThread, parentPort } = worker;
+
+if (isMainThread) {
+  parent();
+} else {
+  if (!parentPort) {
+    console.error('Parent port must not be null');
+    process.exit(100);
+    return;
+  }
+  parentPort.once('message', (msg) => {
+    switch (msg) {
+      case 'child1':
+        return child1();
+      case 'child2':
+        return child2();
+      case 'child3':
+        return child3();
+      case 'child4':
+        return child4();
+      case 'child5':
+        return child5();
+      case 'child6':
+        return child6();
+      case 'child7':
+        return child7();
+      default:
+        throw new Error('invalid');
+    }
+  });
+}
+
+function child1() {
+  process.exitCode = 42;
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 42);
+  });
+}
+
+function child2() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 42);
+  });
+  process.exit(42);
+}
+
+function child3() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 0);
+  });
+  process.exit(0);
+}
+
+function child4() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    // cannot use assert because it will be uncaughtException -> 1 exit code
+    // that will render this test useless
+    if (code !== 1) {
+      console.error('wrong code! expected 1 for uncaughtException');
+      process.exit(99);
+    }
+  });
+  throw new Error('ok');
+}
+
+function child5() {
+  process.exitCode = 95;
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 95);
+    process.exitCode = 99;
+  });
+}
+
+function child6() {
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 0);
+  });
+  process.on('uncaughtException', common.mustCall(() => {
+    // handle
+  }));
+  throw new Error('ok');
+}
+
+function child7() {
+  process.on('exit', (code) => {
+    assert.strictEqual(code, 97);
+  });
+  process.on('uncaughtException', common.mustCall(() => {
+    process.exitCode = 97;
+  }));
+  throw new Error('ok');
+}
+
+function parent() {
+  const test = (arg, exit, error = null) => {
+    const w = new Worker(__filename);
+    w.on('exit', common.mustCall((code) => {
+      assert.strictEqual(
+        code, exit,
+        `wrong exit for ${arg}\nexpected:${exit} but got:${code}`);
+      console.log(`ok - ${arg} exited with ${exit}`);
+    }));
+    if (error) {
+      w.on('error', common.mustCall((err) => {
+        assert(error.test(err));
+      }));
+    }
+    w.postMessage(arg);
+  };
+
+  test('child1', 42);
+  test('child2', 42);
+  test('child3', 0);
+  test('child4', 1, /^Error: ok$/);
+  test('child5', 99);
+  test('child6', 0);
+  test('child7', 97);
+}
diff --git a/test/parallel/test-worker-uncaught-exception-async.js b/test/parallel/test-worker-uncaught-exception-async.js
index c3f0c8dec59f09..f820976c11ebcd 100644
--- a/test/parallel/test-worker-uncaught-exception-async.js
+++ b/test/parallel/test-worker-uncaught-exception-async.js
@@ -12,6 +12,10 @@ if (!process.env.HAS_STARTED_WORKER) {
   w.on('error', common.mustCall((err) => {
     assert(/^Error: foo$/.test(err));
   }));
+  w.on('exit', common.mustCall((code) => {
+    // uncaughtException is code 1
+    assert.strictEqual(code, 1);
+  }));
 } else {
   setImmediate(() => {
     throw new Error('foo');
diff --git a/test/parallel/test-worker-uncaught-exception.js b/test/parallel/test-worker-uncaught-exception.js
index b7d9f8a2928ec1..67b861e22619aa 100644
--- a/test/parallel/test-worker-uncaught-exception.js
+++ b/test/parallel/test-worker-uncaught-exception.js
@@ -12,6 +12,10 @@ if (!process.env.HAS_STARTED_WORKER) {
   w.on('error', common.mustCall((err) => {
     assert(/^Error: foo$/.test(err));
   }));
+  w.on('exit', common.mustCall((code) => {
+    // uncaughtException is code 1
+    assert.strictEqual(code, 1);
+  }));
 } else {
   throw new Error('foo');
 }

From cd6601b87a629f0c82ff28c556929ad68a8761a9 Mon Sep 17 00:00:00 2001
From: Sergey Zelenov <mail@zelenov.su>
Date: Thu, 5 Jul 2018 18:24:56 +0200
Subject: [PATCH 041/116] doc: fix HTTP res 'finish' description

PR-URL: https://github.com/nodejs/node/pull/21670
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/http.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index aa36e304630855..fe1c387654e9c8 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1025,8 +1025,6 @@ emitted when the last segment of the response headers and body have been
 handed off to the operating system for transmission over the network. It
 does not imply that the client has received anything yet.
 
-After this event, no more events will be emitted on the response object.
-
 ### response.addTrailers(headers)
 <!-- YAML
 added: v0.3.0

From 577d24baa41ff2af1d63bc312a3ceab8ee360157 Mon Sep 17 00:00:00 2001
From: Travis Fischer <fisch0920@gmail.com>
Date: Thu, 5 Jul 2018 12:52:53 -0400
Subject: [PATCH 042/116] doc: fix module.children description

Updates the module.children description in the docs to match current
functionality in that it will only contain the modules required for the
first time by this module.

Fixes: https://github.com/nodejs/node/issues/9371

PR-URL: https://github.com/nodejs/node/pull/21672
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/modules.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/modules.md b/doc/api/modules.md
index c46b30560da81f..71de4e519e119a 100644
--- a/doc/api/modules.md
+++ b/doc/api/modules.md
@@ -693,7 +693,7 @@ added: v0.1.16
 
 * {module[]}
 
-The module objects required by this one.
+The module objects required for the first time by this one.
 
 ### module.exports
 <!-- YAML

From f386c0a51758c89d85eb93d502cd50e66c48055e Mon Sep 17 00:00:00 2001
From: Keita Akutsu <kakts.git@gmail.com>
Date: Sat, 7 Jul 2018 02:27:33 +0900
Subject: [PATCH 043/116] test: add test for dns.promises.resolve .

PR-URL: https://github.com/nodejs/node/pull/21691
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-dns-promises-resolve.js | 44 ++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 test/parallel/test-dns-promises-resolve.js

diff --git a/test/parallel/test-dns-promises-resolve.js b/test/parallel/test-dns-promises-resolve.js
new file mode 100644
index 00000000000000..fcaa8977a5ba18
--- /dev/null
+++ b/test/parallel/test-dns-promises-resolve.js
@@ -0,0 +1,44 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+
+const dnsPromises = require('dns').promises;
+
+common.crashOnUnhandledRejection();
+
+// Error when rrtype is invalid.
+{
+  const rrtype = 'DUMMY';
+  common.expectsError(
+    () => dnsPromises.resolve('example.org', rrtype),
+    {
+      code: 'ERR_INVALID_OPT_VALUE',
+      type: TypeError,
+      message: `The value "${rrtype}" is invalid for option "rrtype"`
+    }
+  );
+}
+
+// Error when rrtype is a number.
+{
+  const rrtype = 0;
+  common.expectsError(
+    () => dnsPromises.resolve('example.org', rrtype),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "rrtype" argument must be of type string. ' +
+               `Received type ${typeof rrtype}`
+    }
+  );
+}
+
+// rrtype is undefined, it's same as resolve4
+{
+  (async function() {
+    const rrtype = undefined;
+    const result = await dnsPromises.resolve('example.org', rrtype);
+    assert.ok(result !== undefined);
+    assert.ok(result.length > 0);
+  })();
+}

From c4d7413a15d28599da987c895440702f14c9cd09 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 22 Jun 2018 15:30:14 -0700
Subject: [PATCH 044/116] trace_events: add process_name metadata

PR-URL: https://github.com/nodejs/node/pull/21477
Reviewed-By: Bradley Farias <bradley.meck@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node.cc                                 |  9 +++++++++
 test/parallel/test-trace-events-metadata.js | 13 ++++++++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/node.cc b/src/node.cc
index 7ed25bd2aedcc4..59f64e304c5037 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -2178,6 +2178,8 @@ static void ProcessTitleSetter(Local<Name> property,
                                Local<Value> value,
                                const PropertyCallbackInfo<void>& info) {
   node::Utf8Value title(info.GetIsolate(), value);
+  TRACE_EVENT_METADATA1("__metadata", "process_name", "name",
+                        TRACE_STR_COPY(*title));
   uv_set_process_title(*title);
 }
 
@@ -4074,6 +4076,13 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
   Environment env(isolate_data, context, v8_platform.GetTracingAgent());
   env.Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);
 
+  char name_buffer[512];
+  if (uv_get_process_title(name_buffer, sizeof(name_buffer)) == 0) {
+    // Only emit the metadata event if the title can be retrieved successfully.
+    // Ignore it otherwise.
+    TRACE_EVENT_METADATA1("__metadata", "process_name", "name",
+                          TRACE_STR_COPY(name_buffer));
+  }
   TRACE_EVENT_METADATA1("__metadata", "version", "node", NODE_VERSION_STRING);
   TRACE_EVENT_METADATA1("__metadata", "thread_name", "name",
                         "JavaScriptMainThread");
diff --git a/test/parallel/test-trace-events-metadata.js b/test/parallel/test-trace-events-metadata.js
index 440aa00a9c216c..7f9ccc3c7378d5 100644
--- a/test/parallel/test-trace-events-metadata.js
+++ b/test/parallel/test-trace-events-metadata.js
@@ -8,7 +8,8 @@ if (!common.isMainThread)
   common.skip('process.chdir is not available in Workers');
 
 const CODE =
-  'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1)';
+  'setTimeout(() => { for (var i = 0; i < 100000; i++) { "test" + i } }, 1);' +
+  'process.title = "foo"';
 const FILE_NAME = 'node_trace.1.log';
 
 const tmpdir = require('../common/tmpdir');
@@ -17,6 +18,7 @@ process.chdir(tmpdir.path);
 
 const proc = cp.spawn(process.execPath,
                       [ '--trace-event-categories', 'node.perf.usertiming',
+                        '--title=bar',
                         '-e', CODE ]);
 proc.once('exit', common.mustCall(() => {
   assert(common.fileExists(FILE_NAME));
@@ -32,5 +34,14 @@ proc.once('exit', common.mustCall(() => {
     assert(traces.some((trace) =>
       trace.cat === '__metadata' && trace.name === 'version' &&
         trace.args.node === process.versions.node));
+    if (!common.isSunOS) {
+      // Changing process.title is currently unsupported on SunOS/SmartOS
+      assert(traces.some((trace) =>
+        trace.cat === '__metadata' && trace.name === 'process_name' &&
+          trace.args.name === 'foo'));
+      assert(traces.some((trace) =>
+        trace.cat === '__metadata' && trace.name === 'process_name' &&
+          trace.args.name === 'bar'));
+    }
   }));
 }));

From d06305635d186be4d75d9ede822a86fd627c35ba Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 22 Jun 2018 16:16:03 -0700
Subject: [PATCH 045/116] src: add --title command line argument

Simple utility command line argument for setting the process
title on process startup.

PR-URL: https://github.com/nodejs/node/pull/21477
Reviewed-By: Bradley Farias <bradley.meck@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/cli.md                          |  8 ++++++++
 doc/node.1                              |  3 +++
 src/node.cc                             | 10 ++++++++++
 test/parallel/test-process-title-cli.js | 13 +++++++++++++
 4 files changed, 34 insertions(+)
 create mode 100644 test/parallel/test-process-title-cli.js

diff --git a/doc/api/cli.md b/doc/api/cli.md
index 54ede74e6e4c37..7ebfb084d76abb 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -278,6 +278,13 @@ added: v0.11.14
 
 Throw errors for deprecations.
 
+### `--title=title`
+<!-- YAML
+added: REPLACEME
+-->
+
+Set `process.title` on startup.
+
 ### `--tls-cipher-list=list`
 <!-- YAML
 added: v4.0.0
@@ -539,6 +546,7 @@ Node options that are allowed are:
 - `--redirect-warnings`
 - `--require`, `-r`
 - `--throw-deprecation`
+- `--title`
 - `--tls-cipher-list`
 - `--trace-deprecation`
 - `--trace-event-categories`
diff --git a/doc/node.1 b/doc/node.1
index ac3a8d48a898db..31d39c22681860 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -167,6 +167,9 @@ instead of printing to stderr.
 .It Fl -throw-deprecation
 Throw errors for deprecations.
 .
+.It Fl -title Ns = Ns Ar title
+Specify process.title on startup.
+.
 .It Fl -tls-cipher-list Ns = Ns Ar list
 Specify an alternative default TLS cipher list.
 Requires Node.js to be built with crypto support. (Default)
diff --git a/src/node.cc b/src/node.cc
index 59f64e304c5037..bbf76853ed3c8f 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -277,6 +277,8 @@ std::string config_warning_file;  // NOLINT(runtime/string)
 // that is used by lib/internal/bootstrap/node.js
 bool config_expose_internals = false;
 
+std::string config_process_title;  // NOLINT(runtime/string)
+
 bool v8_initialized = false;
 
 bool linux_at_secure = false;
@@ -3066,6 +3068,7 @@ static void PrintHelp() {
          "                             write warnings to file instead of\n"
          "                             stderr\n"
          "  --throw-deprecation        throw an exception on deprecations\n"
+         "  --title=title              the process title to use on start up\n"
 #if HAVE_OPENSSL
          "  --tls-cipher-list=val      use an alternative default TLS cipher "
          "list\n"
@@ -3204,6 +3207,7 @@ static void CheckIfAllowedInEnv(const char* exe, bool is_env,
     "--redirect-warnings",
     "--require",
     "--throw-deprecation",
+    "--title",
     "--tls-cipher-list",
     "--trace-deprecation",
     "--trace-event-categories",
@@ -3374,6 +3378,8 @@ static void ParseArgs(int* argc,
     } else if (strncmp(arg, "--security-revert=", 18) == 0) {
       const char* cve = arg + 18;
       Revert(cve);
+    } else if (strncmp(arg, "--title=", 8) == 0) {
+      config_process_title = arg + 8;
     } else if (strcmp(arg, "--preserve-symlinks") == 0) {
       config_preserve_symlinks = true;
     } else if (strcmp(arg, "--preserve-symlinks-main") == 0) {
@@ -3868,6 +3874,10 @@ void Init(int* argc,
 
   ProcessArgv(argc, argv, exec_argc, exec_argv);
 
+  // Set the process.title immediately after processing argv if --title is set.
+  if (!config_process_title.empty())
+    uv_set_process_title(config_process_title.c_str());
+
 #if defined(NODE_HAVE_I18N_SUPPORT)
   // If the parameter isn't given, use the env variable.
   if (icu_data_dir.empty())
diff --git a/test/parallel/test-process-title-cli.js b/test/parallel/test-process-title-cli.js
new file mode 100644
index 00000000000000..b6160fed1d0390
--- /dev/null
+++ b/test/parallel/test-process-title-cli.js
@@ -0,0 +1,13 @@
+// Flags: --title=foo
+'use strict';
+
+const common = require('../common');
+
+if (common.isSunOS)
+  common.skip(`Unsupported platform [${process.platform}]`);
+
+const assert = require('assert');
+
+// Verifies that the --title=foo command line flag set the process
+// title on startup.
+assert.strictEqual(process.title, 'foo');

From 6920091488b5d8bef993e2cf1bb936d52ecea138 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Mon, 9 Jul 2018 22:16:25 -0400
Subject: [PATCH 046/116] deps: upgrade to libuv 1.22.0

PR-URL: https://github.com/nodejs/node/pull/21731
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 deps/uv/AUTHORS                   |   2 +
 deps/uv/CMakeLists.txt            |   3 +-
 deps/uv/ChangeLog                 |  33 ++++
 deps/uv/MAINTAINERS.md            |   2 +-
 deps/uv/Makefile.am               |   3 +-
 deps/uv/checksparse.sh            | 254 ------------------------------
 deps/uv/configure.ac              |   2 +-
 deps/uv/docs/src/errors.rst       |  14 ++
 deps/uv/docs/src/fs.rst           |   4 +-
 deps/uv/include/uv.h              |   7 +-
 deps/uv/include/uv/version.h      |   2 +-
 deps/uv/include/uv/win.h          |  11 +-
 deps/uv/src/fs-poll.c             |   4 +-
 deps/uv/src/{unix => }/timer.c    |  19 ++-
 deps/uv/src/unix/core.c           |  18 ++-
 deps/uv/src/unix/fsevents.c       |   2 +-
 deps/uv/src/unix/internal.h       |  25 ---
 deps/uv/src/unix/loop.c           |   4 +-
 deps/uv/src/unix/os390-syscalls.c |  29 ++--
 deps/uv/src/unix/pipe.c           |   4 +-
 deps/uv/src/unix/process.c        |   4 +-
 deps/uv/src/unix/signal.c         |  20 +--
 deps/uv/src/unix/stream.c         |  91 +++++------
 deps/uv/src/unix/tcp.c            |  18 +--
 deps/uv/src/unix/tty.c            |   8 +-
 deps/uv/src/unix/udp.c            |   8 +-
 deps/uv/src/uv-common.c           |  35 +++-
 deps/uv/src/uv-common.h           | 115 ++++++++++----
 deps/uv/src/win/async.c           |   6 +-
 deps/uv/src/win/core.c            |  28 +++-
 deps/uv/src/win/fs-event.c        |   8 +-
 deps/uv/src/win/handle-inl.h      |  17 +-
 deps/uv/src/win/handle.c          |   8 +-
 deps/uv/src/win/internal.h        |  72 ---------
 deps/uv/src/win/loop-watcher.c    |   2 +-
 deps/uv/src/win/pipe.c            |  19 ++-
 deps/uv/src/win/poll.c            |  10 +-
 deps/uv/src/win/process-stdio.c   |   3 +-
 deps/uv/src/win/process.c         |   4 +-
 deps/uv/src/win/signal.c          |  14 +-
 deps/uv/src/win/stream.c          |   2 +-
 deps/uv/src/win/tcp.c             |   8 +-
 deps/uv/src/win/thread.c          |  11 +-
 deps/uv/src/win/timer.c           | 195 -----------------------
 deps/uv/src/win/tty.c             |   4 +-
 deps/uv/src/win/udp.c             |   2 +-
 deps/uv/test/test-condvar.c       | 246 ++++++++++++++++-------------
 deps/uv/test/test-error.c         |   6 +
 deps/uv/test/test-list.h          |   2 -
 deps/uv/test/test-tty.c           |   6 +-
 deps/uv/uv.gyp                    |   3 +-
 51 files changed, 527 insertions(+), 890 deletions(-)
 delete mode 100755 deps/uv/checksparse.sh
 rename deps/uv/src/{unix => }/timer.c (92%)
 delete mode 100644 deps/uv/src/win/timer.c

diff --git a/deps/uv/AUTHORS b/deps/uv/AUTHORS
index eb8501aab12d45..ef3d5e181a800f 100644
--- a/deps/uv/AUTHORS
+++ b/deps/uv/AUTHORS
@@ -343,3 +343,5 @@ Björn Linse <bjorn.linse@gmail.com>
 zyxwvu Shi <i@shiyc.cn>
 Peter Johnson <johnson.peter@gmail.com>
 Paolo Greppi <paolo.greppi@libpf.com>
+Shelley Vohr <shelley.vohr@gmail.com>
+Ujjwal Sharma <usharma1998@gmail.com>
diff --git a/deps/uv/CMakeLists.txt b/deps/uv/CMakeLists.txt
index f13e5295636b49..a133edb8500fa2 100644
--- a/deps/uv/CMakeLists.txt
+++ b/deps/uv/CMakeLists.txt
@@ -15,6 +15,7 @@ set(uv_sources
     src/fs-poll.c
     src/inet.c
     src/threadpool.c
+    src/timer.c
     src/uv-common.c
     src/uv-data-getter-setters.c
     src/version.c)
@@ -197,7 +198,6 @@ if(WIN32)
        src/win/stream.c
        src/win/tcp.c
        src/win/tty.c
-       src/win/timer.c
        src/win/udp.c
        src/win/util.c
        src/win/winapi.c
@@ -223,7 +223,6 @@ else()
        src/unix/stream.c
        src/unix/tcp.c
        src/unix/thread.c
-       src/unix/timer.c
        src/unix/tty.c
        src/unix/udp.c)
   list(APPEND uv_test_sources test/runner-unix.c)
diff --git a/deps/uv/ChangeLog b/deps/uv/ChangeLog
index 3569d5d5751564..acf42e0123a6c1 100644
--- a/deps/uv/ChangeLog
+++ b/deps/uv/ChangeLog
@@ -1,3 +1,36 @@
+2018.07.11, Version 1.22.0 (Stable), 8568f78a777d79d35eb7d6994617267b9fb33967
+
+Changes since version 1.21.0:
+
+* unix: remove checksparse.sh (Ben Noordhuis)
+
+* win: fix mingw build error (Ben Noordhuis)
+
+* win: fix -Wunused-function warnings in thread.c (Ben Noordhuis)
+
+* unix,win: merge timers implementation (Ben Noordhuis)
+
+* win: fix pointer type in pipe.c (Ben Noordhuis)
+
+* win: fixing build for older MSVC compilers (Michael Fero)
+
+* zos: clear poll events on every iteration (jBarz)
+
+* zos: write-protect message queue (jBarz)
+
+* zos: use correct pointer type in strnlen (jBarz)
+
+* unix,win: merge handle flags (Ben Noordhuis)
+
+* doc: update Imran Iqbal's GitHub handle (cjihrig)
+
+* src: add new error apis to prevent memory leaks (Shelley Vohr)
+
+* test: make test-condvar call uv_cond_wait (Jamie Davis)
+
+* fs: change position of uv_fs_lchown (Ujjwal Sharma)
+
+
 2018.06.23, Version 1.21.0 (Stable), e4983a9b0c152932f7553ff4a9ff189d2314cdcb
 
 Changes since version 1.20.3:
diff --git a/deps/uv/MAINTAINERS.md b/deps/uv/MAINTAINERS.md
index a895780fc11809..889ee4988c482c 100644
--- a/deps/uv/MAINTAINERS.md
+++ b/deps/uv/MAINTAINERS.md
@@ -12,7 +12,7 @@ libuv is currently managed by the following individuals:
   - GPG key: 5735 3E0D BDAA A7E8 39B6  6A1A FF47 D5E4 AD8B 4FDC (pubkey-cjihrig-kb)
 * **Fedor Indutny** ([@indutny](https://github.com/indutny))
   - GPG key: AF2E EA41 EC34 47BF DD86  FED9 D706 3CCE 19B7 E890 (pubkey-indutny)
-* **Imran Iqbal** ([@iWuzHere](https://github.com/iWuzHere))
+* **Imran Iqbal** ([@imran-iq](https://github.com/imran-iq))
   - GPG key: 9DFE AA5F 481B BF77 2D90  03CE D592 4925 2F8E C41A (pubkey-iwuzhere)
 * **John Barboza** ([@jbarz](https://github.com/jbarz))
 * **Santiago Gimeno** ([@santigimeno](https://github.com/santigimeno))
diff --git a/deps/uv/Makefile.am b/deps/uv/Makefile.am
index 5f07dba23a3b7d..04aecab5555886 100644
--- a/deps/uv/Makefile.am
+++ b/deps/uv/Makefile.am
@@ -32,6 +32,7 @@ libuv_la_SOURCES = src/fs-poll.c \
                    src/inet.c \
                    src/queue.h \
                    src/threadpool.c \
+                   src/timer.c \
                    src/uv-data-getter-setters.c \
                    src/uv-common.c \
                    src/uv-common.h \
@@ -74,7 +75,6 @@ libuv_la_SOURCES += src/win/async.c \
                     src/win/stream-inl.h \
                     src/win/tcp.c \
                     src/win/thread.c \
-                    src/win/timer.c \
                     src/win/tty.c \
                     src/win/udp.c \
                     src/win/util.c \
@@ -105,7 +105,6 @@ libuv_la_SOURCES += src/unix/async.c \
                    src/unix/stream.c \
                    src/unix/tcp.c \
                    src/unix/thread.c \
-                   src/unix/timer.c \
                    src/unix/tty.c \
                    src/unix/udp.c
 
diff --git a/deps/uv/checksparse.sh b/deps/uv/checksparse.sh
deleted file mode 100755
index 91f130d4f5893c..00000000000000
--- a/deps/uv/checksparse.sh
+++ /dev/null
@@ -1,254 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
-#
-# Permission to use, copy, modify, and/or distribute this software for any
-# purpose with or without fee is hereby granted, provided that the above
-# copyright notice and this permission notice appear in all copies.
-#
-# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-SPARSE=${SPARSE:-sparse}
-
-SPARSE_FLAGS=${SPARSE_FLAGS:-"
--D__POSIX__
--Wsparse-all
--Wno-do-while
--Wno-transparent-union
--Iinclude
--Isrc
-"}
-
-SOURCES="
-include/uv/tree.h
-include/uv/unix.h
-include/uv.h
-src/fs-poll.c
-src/inet.c
-src/queue.h
-src/unix/async.c
-src/unix/core.c
-src/unix/dl.c
-src/unix/fs.c
-src/unix/getaddrinfo.c
-src/unix/internal.h
-src/unix/loop-watcher.c
-src/unix/loop.c
-src/unix/pipe.c
-src/unix/poll.c
-src/unix/process.c
-src/unix/signal.c
-src/unix/stream.c
-src/unix/tcp.c
-src/unix/thread.c
-src/unix/threadpool.c
-src/unix/timer.c
-src/unix/tty.c
-src/unix/udp.c
-src/uv-common.c
-src/uv-common.h
-src/uv-data-getter-setters.c
-"
-
-TESTS="
-test/benchmark-async-pummel.c
-test/benchmark-async.c
-test/benchmark-fs-stat.c
-test/benchmark-getaddrinfo.c
-test/benchmark-loop-count.c
-test/benchmark-million-async.c
-test/benchmark-million-timers.c
-test/benchmark-multi-accept.c
-test/benchmark-ping-pongs.c
-test/benchmark-pound.c
-test/benchmark-pump.c
-test/benchmark-sizes.c
-test/benchmark-spawn.c
-test/benchmark-tcp-write-batch.c
-test/benchmark-thread.c
-test/benchmark-udp-pummel.c
-test/blackhole-server.c
-test/dns-server.c
-test/echo-server.c
-test/run-benchmarks.c
-test/run-tests.c
-test/runner-unix.c
-test/runner-unix.h
-test/runner.c
-test/runner.h
-test/task.h
-test/test-active.c
-test/test-async.c
-test/test-barrier.c
-test/test-callback-order.c
-test/test-callback-stack.c
-test/test-condvar.c
-test/test-connection-fail.c
-test/test-cwd-and-chdir.c
-test/test-delayed-accept.c
-test/test-dlerror.c
-test/test-embed.c
-test/test-env-vars.c
-test/test-error.c
-test/test-fail-always.c
-test/test-fs-copyfile.c
-test/test-fs-event.c
-test/test-fs-poll.c
-test/test-fs.c
-test/test-getters-setters.c
-test/test-get-currentexe.c
-test/test-get-loadavg.c
-test/test-get-memory.c
-test/test-get-passwd.c
-test/test-getaddrinfo.c
-test/test-gethostname.c
-test/test-getsockname.c
-test/test-homedir.c
-test/test-hrtime.c
-test/test-idle.c
-test/test-ip6-addr.c
-test/test-ipc-heavy-traffic-deadlock-bug.c
-test/test-ipc-send-recv.c
-test/test-ipc.c
-test/test-loop-handles.c
-test/test-multiple-listen.c
-test/test-mutexes.c
-test/test-pass-always.c
-test/test-ping-pong.c
-test/test-pipe-bind-error.c
-test/test-pipe-connect-error.c
-test/test-pipe-sendmsg.c
-test/test-pipe-server-close.c
-test/test-platform-output.c
-test/test-poll-close.c
-test/test-poll.c
-test/test-process-title.c
-test/test-process-title-threadsafe.c
-test/test-ref.c
-test/test-run-nowait.c
-test/test-run-once.c
-test/test-semaphore.c
-test/test-shutdown-close.c
-test/test-shutdown-eof.c
-test/test-signal-multiple-loops.c
-test/test-signal.c
-test/test-spawn.c
-test/test-stdio-over-pipes.c
-test/test-tcp-bind-error.c
-test/test-tcp-bind6-error.c
-test/test-tcp-close-while-connecting.c
-test/test-tcp-close-accept.c
-test/test-tcp-close.c
-test/test-tcp-connect-error-after-write.c
-test/test-tcp-connect-error.c
-test/test-tcp-connect-timeout.c
-test/test-tcp-connect6-error.c
-test/test-tcp-flags.c
-test/test-tcp-open.c
-test/test-tcp-read-stop.c
-test/test-tcp-shutdown-after-write.c
-test/test-tcp-unexpected-read.c
-test/test-tcp-oob.c
-test/test-tcp-write-error.c
-test/test-tcp-write-to-half-open-connection.c
-test/test-tcp-writealot.c
-test/test-thread.c
-test/test-threadpool-cancel.c
-test/test-threadpool.c
-test/test-timer-again.c
-test/test-timer.c
-test/test-tmpdir.c
-test/test-tty.c
-test/test-udp-dgram-too-big.c
-test/test-udp-ipv6.c
-test/test-udp-multicast-join.c
-test/test-udp-multicast-ttl.c
-test/test-udp-open.c
-test/test-udp-options.c
-test/test-udp-send-and-recv.c
-test/test-udp-send-hang-loop.c
-test/test-walk-handles.c
-test/test-watcher-cross-stop.c
-"
-
-case `uname -s` in
-AIX)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D_AIX=1"
-  SOURCES="$SOURCES
-           src/unix/aix-common.c
-           src/unix/aix.c"
-  ;;
-OS400)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__PASE__=1"
-  SOURCES="$SOURCES
-           src/unix/aix-common.c
-           src/unix/ibmi.c
-           src/unix/posix-poll.c
-           src/unix/no-fsevents.c
-           src/unix/no-proctitle.c"
-  ;;
-Darwin)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__APPLE__=1"
-  SOURCES="$SOURCES
-           include/uv/bsd.h
-           src/unix/darwin.c
-           src/unix/kqueue.c
-           src/unix/fsevents.c"
-  ;;
-DragonFly)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__DragonFly__=1"
-  SOURCES="$SOURCES
-           include/uv/bsd.h
-           src/unix/kqueue.c
-           src/unix/freebsd.c"
-  ;;
-FreeBSD)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__FreeBSD__=1"
-  SOURCES="$SOURCES
-           include/uv/bsd.h
-           src/unix/kqueue.c
-           src/unix/freebsd.c"
-  ;;
-Linux)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__linux__=1"
-  SOURCES="$SOURCES
-           include/uv/linux.h
-           src/unix/linux-inotify.c
-           src/unix/linux-core.c
-           src/unix/linux-syscalls.c
-           src/unix/linux-syscalls.h"
-  ;;
-NetBSD)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__NetBSD__=1"
-  SOURCES="$SOURCES
-           include/uv/bsd.h
-           src/unix/kqueue.c
-           src/unix/netbsd.c"
-  ;;
-OpenBSD)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__OpenBSD__=1"
-  SOURCES="$SOURCES
-           include/uv/bsd.h
-           src/unix/kqueue.c
-           src/unix/openbsd.c"
-  ;;
-SunOS)
-  SPARSE_FLAGS="$SPARSE_FLAGS -D__sun=1"
-  SOURCES="$SOURCES
-           include/uv/sunos.h
-           src/unix/sunos.c"
-  ;;
-esac
-
-for ARCH in __i386__ __x86_64__ __arm__ __mips__; do
-  $SPARSE $SPARSE_FLAGS -D$ARCH=1 $SOURCES
-done
-
-# Tests are architecture independent.
-$SPARSE $SPARSE_FLAGS -Itest $TESTS
diff --git a/deps/uv/configure.ac b/deps/uv/configure.ac
index c3a6a7796904c8..aa6e6d16a8c804 100644
--- a/deps/uv/configure.ac
+++ b/deps/uv/configure.ac
@@ -13,7 +13,7 @@
 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 AC_PREREQ(2.57)
-AC_INIT([libuv], [1.21.0], [https://github.com/libuv/libuv/issues])
+AC_INIT([libuv], [1.22.0], [https://github.com/libuv/libuv/issues])
 AC_CONFIG_MACRO_DIR([m4])
 m4_include([m4/libuv-extra-automake-flags.m4])
 m4_include([m4/as_case.m4])
diff --git a/deps/uv/docs/src/errors.rst b/deps/uv/docs/src/errors.rst
index 7c3f95d760416f..b8f971f5763511 100644
--- a/deps/uv/docs/src/errors.rst
+++ b/deps/uv/docs/src/errors.rst
@@ -335,11 +335,25 @@ API
     Returns the error message for the given error code.  Leaks a few bytes
     of memory when you call it with an unknown error code.
 
+.. c:function:: char* uv_strerror_r(int err, char* buf, size_t buflen)
+
+    Returns the error message for the given error code. The zero-terminated
+    message is stored in the user-supplied buffer `buf` of at most `buflen` bytes.
+
+    .. versionadded:: 1.22.0
+
 .. c:function:: const char* uv_err_name(int err)
 
     Returns the error name for the given error code.  Leaks a few bytes
     of memory when you call it with an unknown error code.
 
+.. c:function:: char* uv_err_name_r(int err, char* buf, size_t buflen)
+
+    Returns the error name for the given error code. The zero-terminated
+    name is stored in the user-supplied buffer `buf` of at most `buflen` bytes.
+
+    .. versionadded:: 1.22.0
+
 .. c:function:: int uv_translate_sys_error(int sys_errno)
 
    Returns the libuv error code equivalent to the given platform dependent error
diff --git a/deps/uv/docs/src/fs.rst b/deps/uv/docs/src/fs.rst
index a390f1409d2f26..f383e5b10cd9d5 100644
--- a/deps/uv/docs/src/fs.rst
+++ b/deps/uv/docs/src/fs.rst
@@ -92,9 +92,9 @@ Data types
             UV_FS_READLINK,
             UV_FS_CHOWN,
             UV_FS_FCHOWN,
-            UV_FS_LCHOWN,
             UV_FS_REALPATH,
-            UV_FS_COPYFILE
+            UV_FS_COPYFILE,
+            UV_FS_LCHOWN
         } uv_fs_type;
 
 .. c:type:: uv_dirent_t
diff --git a/deps/uv/include/uv.h b/deps/uv/include/uv.h
index 91451ada7885c2..a8b305793d4b14 100644
--- a/deps/uv/include/uv.h
+++ b/deps/uv/include/uv.h
@@ -370,7 +370,10 @@ typedef enum {
 UV_EXTERN int uv_translate_sys_error(int sys_errno);
 
 UV_EXTERN const char* uv_strerror(int err);
+UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen);
+
 UV_EXTERN const char* uv_err_name(int err);
+UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen);
 
 
 #define UV_REQ_FIELDS                                                         \
@@ -1141,9 +1144,9 @@ typedef enum {
   UV_FS_READLINK,
   UV_FS_CHOWN,
   UV_FS_FCHOWN,
-  UV_FS_LCHOWN,
   UV_FS_REALPATH,
-  UV_FS_COPYFILE
+  UV_FS_COPYFILE,
+  UV_FS_LCHOWN
 } uv_fs_type;
 
 /* uv_fs_t is a subclass of uv_req_t. */
diff --git a/deps/uv/include/uv/version.h b/deps/uv/include/uv/version.h
index 0b829717b81ab0..a990137f85209c 100644
--- a/deps/uv/include/uv/version.h
+++ b/deps/uv/include/uv/version.h
@@ -31,7 +31,7 @@
  */
 
 #define UV_VERSION_MAJOR 1
-#define UV_VERSION_MINOR 21
+#define UV_VERSION_MINOR 22
 #define UV_VERSION_PATCH 0
 #define UV_VERSION_IS_RELEASE 1
 #define UV_VERSION_SUFFIX ""
diff --git a/deps/uv/include/uv/win.h b/deps/uv/include/uv/win.h
index f01335296a05e9..d6b8b3a7f7b9a2 100644
--- a/deps/uv/include/uv/win.h
+++ b/deps/uv/include/uv/win.h
@@ -308,8 +308,6 @@ typedef struct {
   char* errmsg;
 } uv_lib_t;
 
-RB_HEAD(uv_timer_tree_s, uv_timer_s);
-
 #define UV_LOOP_PRIVATE_FIELDS                                                \
     /* The loop's I/O completion port */                                      \
   HANDLE iocp;                                                                \
@@ -321,8 +319,8 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
   uv_req_t* pending_reqs_tail;                                                \
   /* Head of a single-linked list of closed handles */                        \
   uv_handle_t* endgame_handles;                                               \
-  /* The head of the timers tree */                                           \
-  struct uv_timer_tree_s timers;                                              \
+  /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */     \
+  void* timer_heap;                                                           \
     /* Lists of active loop (prepare / check / idle) watchers */              \
   uv_prepare_t* prepare_handles;                                              \
   uv_check_t* check_handles;                                                  \
@@ -529,8 +527,9 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
   unsigned char events;
 
 #define UV_TIMER_PRIVATE_FIELDS                                               \
-  RB_ENTRY(uv_timer_s) tree_entry;                                            \
-  uint64_t due;                                                               \
+  void* heap_node[3];                                                         \
+  int unused;                                                                 \
+  uint64_t timeout;                                                           \
   uint64_t repeat;                                                            \
   uint64_t start_id;                                                          \
   uv_timer_cb timer_cb;
diff --git a/deps/uv/src/fs-poll.c b/deps/uv/src/fs-poll.c
index ee73d5a2e6e949..6c82dfc1d76302 100644
--- a/deps/uv/src/fs-poll.c
+++ b/deps/uv/src/fs-poll.c
@@ -83,7 +83,7 @@ int uv_fs_poll_start(uv_fs_poll_t* handle,
   if (err < 0)
     goto error;
 
-  ctx->timer_handle.flags |= UV__HANDLE_INTERNAL;
+  ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
   uv__handle_unref(&ctx->timer_handle);
 
   err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
@@ -248,7 +248,7 @@ static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
 #include "win/handle-inl.h"
 
 void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
-  assert(handle->flags & UV__HANDLE_CLOSING);
+  assert(handle->flags & UV_HANDLE_CLOSING);
   assert(!(handle->flags & UV_HANDLE_CLOSED));
   uv__handle_close(handle);
 }
diff --git a/deps/uv/src/unix/timer.c b/deps/uv/src/timer.c
similarity index 92%
rename from deps/uv/src/unix/timer.c
rename to deps/uv/src/timer.c
index 54dabfe7df9e27..2bf449a736c2bb 100644
--- a/deps/uv/src/unix/timer.c
+++ b/deps/uv/src/timer.c
@@ -19,13 +19,22 @@
  */
 
 #include "uv.h"
-#include "internal.h"
+#include "uv-common.h"
 #include "heap-inl.h"
 
 #include <assert.h>
 #include <limits.h>
 
 
+static struct heap *timer_heap(const uv_loop_t* loop) {
+#ifdef _WIN32
+  return (struct heap*) loop->timer_heap;
+#else
+  return (struct heap*) &loop->timer_heap;
+#endif
+}
+
+
 static int timer_less_than(const struct heap_node* ha,
                            const struct heap_node* hb) {
   const uv_timer_t* a;
@@ -81,7 +90,7 @@ int uv_timer_start(uv_timer_t* handle,
   /* start_id is the second index to be compared in uv__timer_cmp() */
   handle->start_id = handle->loop->timer_counter++;
 
-  heap_insert((struct heap*) &handle->loop->timer_heap,
+  heap_insert(timer_heap(handle->loop),
               (struct heap_node*) &handle->heap_node,
               timer_less_than);
   uv__handle_start(handle);
@@ -94,7 +103,7 @@ int uv_timer_stop(uv_timer_t* handle) {
   if (!uv__is_active(handle))
     return 0;
 
-  heap_remove((struct heap*) &handle->loop->timer_heap,
+  heap_remove(timer_heap(handle->loop),
               (struct heap_node*) &handle->heap_node,
               timer_less_than);
   uv__handle_stop(handle);
@@ -131,7 +140,7 @@ int uv__next_timeout(const uv_loop_t* loop) {
   const uv_timer_t* handle;
   uint64_t diff;
 
-  heap_node = heap_min((const struct heap*) &loop->timer_heap);
+  heap_node = heap_min(timer_heap(loop));
   if (heap_node == NULL)
     return -1; /* block indefinitely */
 
@@ -152,7 +161,7 @@ void uv__run_timers(uv_loop_t* loop) {
   uv_timer_t* handle;
 
   for (;;) {
-    heap_node = heap_min((struct heap*) &loop->timer_heap);
+    heap_node = heap_min(timer_heap(loop));
     if (heap_node == NULL)
       break;
 
diff --git a/deps/uv/src/unix/core.c b/deps/uv/src/unix/core.c
index c2e7bd730d5d45..066c9bee32e2b2 100644
--- a/deps/uv/src/unix/core.c
+++ b/deps/uv/src/unix/core.c
@@ -116,7 +116,7 @@ uint64_t uv_hrtime(void) {
 void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
   assert(!uv__is_closing(handle));
 
-  handle->flags |= UV_CLOSING;
+  handle->flags |= UV_HANDLE_CLOSING;
   handle->close_cb = close_cb;
 
   switch (handle->type) {
@@ -214,8 +214,8 @@ int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value) {
 }
 
 void uv__make_close_pending(uv_handle_t* handle) {
-  assert(handle->flags & UV_CLOSING);
-  assert(!(handle->flags & UV_CLOSED));
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
   handle->next_closing = handle->loop->closing_handles;
   handle->loop->closing_handles = handle;
 }
@@ -241,15 +241,17 @@ int uv__getiovmax(void) {
 
 
 static void uv__finish_close(uv_handle_t* handle) {
-  /* Note: while the handle is in the UV_CLOSING state now, it's still possible
-   * for it to be active in the sense that uv__is_active() returns true.
+  /* Note: while the handle is in the UV_HANDLE_CLOSING state now, it's still
+   * possible for it to be active in the sense that uv__is_active() returns
+   * true.
+   *
    * A good example is when the user calls uv_shutdown(), immediately followed
    * by uv_close(). The handle is considered active at this point because the
    * completion of the shutdown req is still pending.
    */
-  assert(handle->flags & UV_CLOSING);
-  assert(!(handle->flags & UV_CLOSED));
-  handle->flags |= UV_CLOSED;
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
+  handle->flags |= UV_HANDLE_CLOSED;
 
   switch (handle->type) {
     case UV_PREPARE:
diff --git a/deps/uv/src/unix/fsevents.c b/deps/uv/src/unix/fsevents.c
index 47d8024b6d51ba..ee45299b791294 100644
--- a/deps/uv/src/unix/fsevents.c
+++ b/deps/uv/src/unix/fsevents.c
@@ -836,7 +836,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) {
 
   handle->cf_cb->data = handle;
   uv_async_init(handle->loop, handle->cf_cb, uv__fsevents_cb);
-  handle->cf_cb->flags |= UV__HANDLE_INTERNAL;
+  handle->cf_cb->flags |= UV_HANDLE_INTERNAL;
   uv_unref((uv_handle_t*) handle->cf_cb);
 
   err = uv_mutex_init(&handle->cf_mutex);
diff --git a/deps/uv/src/unix/internal.h b/deps/uv/src/unix/internal.h
index b0c5dcadf155f6..cd79037102013e 100644
--- a/deps/uv/src/unix/internal.h
+++ b/deps/uv/src/unix/internal.h
@@ -127,26 +127,6 @@ int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset);
 
 typedef struct uv__stream_queued_fds_s uv__stream_queued_fds_t;
 
-/* handle flags */
-enum {
-  UV_CLOSING              = 0x01,   /* uv_close() called but not finished. */
-  UV_CLOSED               = 0x02,   /* close(2) finished. */
-  UV_STREAM_READING       = 0x04,   /* uv_read_start() called. */
-  UV_STREAM_SHUTTING      = 0x08,   /* uv_shutdown() called but not complete. */
-  UV_STREAM_SHUT          = 0x10,   /* Write side closed. */
-  UV_STREAM_READABLE      = 0x20,   /* The stream is readable */
-  UV_STREAM_WRITABLE      = 0x40,   /* The stream is writable */
-  UV_STREAM_BLOCKING      = 0x80,   /* Synchronous writes. */
-  UV_STREAM_READ_PARTIAL  = 0x100,  /* read(2) read less than requested. */
-  UV_STREAM_READ_EOF      = 0x200,  /* read(2) read EOF. */
-  UV_TCP_NODELAY          = 0x400,  /* Disable Nagle. */
-  UV_TCP_KEEPALIVE        = 0x800,  /* Turn on keep-alive. */
-  UV_TCP_SINGLE_ACCEPT    = 0x1000, /* Only accept() when idle. */
-  UV_HANDLE_IPV6          = 0x10000, /* Handle is bound to a IPv6 socket. */
-  UV_UDP_PROCESSING       = 0x20000, /* Handle is running the send callback queue. */
-  UV_HANDLE_BOUND         = 0x40000  /* Handle is bound to an address and port */
-};
-
 /* loop flags */
 enum {
   UV_LOOP_BLOCK_SIGPROF = 1
@@ -252,10 +232,6 @@ int uv__tcp_keepalive(int fd, int on, unsigned int delay);
 /* pipe */
 int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
 
-/* timer */
-void uv__run_timers(uv_loop_t* loop);
-int uv__next_timeout(const uv_loop_t* loop);
-
 /* signal */
 void uv__signal_close(uv_signal_t* handle);
 void uv__signal_global_once_init(void);
@@ -280,7 +256,6 @@ void uv__prepare_close(uv_prepare_t* handle);
 void uv__process_close(uv_process_t* handle);
 void uv__stream_close(uv_stream_t* handle);
 void uv__tcp_close(uv_tcp_t* handle);
-void uv__timer_close(uv_timer_t* handle);
 void uv__udp_close(uv_udp_t* handle);
 void uv__udp_finish_close(uv_udp_t* handle);
 uv_handle_type uv__handle_type(int fd);
diff --git a/deps/uv/src/unix/loop.c b/deps/uv/src/unix/loop.c
index f990403d40c059..c2a03d770f3764 100644
--- a/deps/uv/src/unix/loop.c
+++ b/deps/uv/src/unix/loop.c
@@ -74,7 +74,7 @@ int uv_loop_init(uv_loop_t* loop) {
     goto fail_signal_init;
 
   uv__handle_unref(&loop->child_watcher);
-  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;
+  loop->child_watcher.flags |= UV_HANDLE_INTERNAL;
   QUEUE_INIT(&loop->process_handles);
 
   err = uv_rwlock_init(&loop->cloexec_lock);
@@ -90,7 +90,7 @@ int uv_loop_init(uv_loop_t* loop) {
     goto fail_async_init;
 
   uv__handle_unref(&loop->wq_async);
-  loop->wq_async.flags |= UV__HANDLE_INTERNAL;
+  loop->wq_async.flags |= UV_HANDLE_INTERNAL;
 
   return 0;
 
diff --git a/deps/uv/src/unix/os390-syscalls.c b/deps/uv/src/unix/os390-syscalls.c
index a5dd34426de969..1040d66979da04 100644
--- a/deps/uv/src/unix/os390-syscalls.c
+++ b/deps/uv/src/unix/os390-syscalls.c
@@ -141,7 +141,7 @@ static void init_message_queue(uv__os390_epoll* lst) {
   } msg;
 
   /* initialize message queue */
-  lst->msg_queue = msgget(IPC_PRIVATE, 0622 | IPC_CREAT);
+  lst->msg_queue = msgget(IPC_PRIVATE, 0600 | IPC_CREAT);
   if (lst->msg_queue == -1)
     abort();
 
@@ -255,12 +255,13 @@ int epoll_ctl(uv__os390_epoll* lst,
     lst->items[fd].events = event->events;
     lst->items[fd].revents = 0;
   } else if (op == EPOLL_CTL_MOD) {
-    if (fd >= lst->size || lst->items[fd].fd == -1) {
+    if (fd >= lst->size - 1 || lst->items[fd].fd == -1) {
       uv_mutex_unlock(&global_epoll_lock);
       errno = ENOENT;
       return -1;
     }
     lst->items[fd].events = event->events;
+    lst->items[fd].revents = 0;
   } else
     abort();
 
@@ -275,8 +276,9 @@ int epoll_wait(uv__os390_epoll* lst, struct epoll_event* events,
   struct pollfd* pfds;
   int pollret;
   int reventcount;
+  int nevents;
 
-  size = _SET_FDS_MSGS(size, 1, lst->size - 1);
+  _SET_FDS_MSGS(size, 1, lst->size - 1);
   pfds = lst->items;
   pollret = poll(pfds, size, timeout);
   if (pollret <= 0)
@@ -285,19 +287,28 @@ int epoll_wait(uv__os390_epoll* lst, struct epoll_event* events,
   pollret = _NFDS(pollret) + _NMSGS(pollret);
 
   reventcount = 0;
+  nevents = 0;
   for (int i = 0; 
        i < lst->size && i < maxevents && reventcount < pollret; ++i) {
     struct epoll_event ev;
+    struct pollfd* pfd;
 
-    if (pfds[i].fd == -1 || pfds[i].revents == 0)
+    pfd = &pfds[i];
+    if (pfd->fd == -1 || pfd->revents == 0)
       continue;
 
-    ev.fd = pfds[i].fd;
-    ev.events = pfds[i].revents;
-    events[reventcount++] = ev;
+    ev.fd = pfd->fd;
+    ev.events = pfd->revents;
+    if (pfd->revents & POLLIN && pfd->revents & POLLOUT)
+      reventcount += 2;
+    else if (pfd->revents & (POLLIN | POLLOUT))
+      ++reventcount;
+
+    pfd->revents = 0;
+    events[nevents++] = ev;
   }
 
-  return reventcount;
+  return nevents;
 }
 
 
@@ -493,7 +504,7 @@ ssize_t os390_readlink(const char* path, char* buf, size_t len) {
 
 
 size_t strnlen(const char* str, size_t maxlen) {
-  void* p = memchr(str, 0, maxlen);
+  char* p = memchr(str, 0, maxlen);
   if (p == NULL)
     return maxlen;
   else
diff --git a/deps/uv/src/unix/pipe.c b/deps/uv/src/unix/pipe.c
index 91114db6162f8c..0718bc81b86f63 100644
--- a/deps/uv/src/unix/pipe.c
+++ b/deps/uv/src/unix/pipe.c
@@ -149,7 +149,7 @@ int uv_pipe_open(uv_pipe_t* handle, uv_file fd) {
 
   return uv__stream_open((uv_stream_t*)handle,
                          fd,
-                         UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
 }
 
 
@@ -199,7 +199,7 @@ void uv_pipe_connect(uv_connect_t* req,
   if (new_sock) {
     err = uv__stream_open((uv_stream_t*)handle,
                           uv__stream_fd(handle),
-                          UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+                          UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
   }
 
   if (err == 0)
diff --git a/deps/uv/src/unix/process.c b/deps/uv/src/unix/process.c
index 3a3cfd6f092fa4..101c9c53dfafe3 100644
--- a/deps/uv/src/unix/process.c
+++ b/deps/uv/src/unix/process.c
@@ -239,9 +239,9 @@ static int uv__process_open_stream(uv_stdio_container_t* container,
 
   flags = 0;
   if (container->flags & UV_WRITABLE_PIPE)
-    flags |= UV_STREAM_READABLE;
+    flags |= UV_HANDLE_READABLE;
   if (container->flags & UV_READABLE_PIPE)
-    flags |= UV_STREAM_WRITABLE;
+    flags |= UV_HANDLE_WRITABLE;
 
   return uv__stream_open(container->data.stream, pipefds[0], flags);
 }
diff --git a/deps/uv/src/unix/signal.c b/deps/uv/src/unix/signal.c
index 8da08b86802425..01aa55f3fe7c66 100644
--- a/deps/uv/src/unix/signal.c
+++ b/deps/uv/src/unix/signal.c
@@ -396,7 +396,7 @@ static int uv__signal_start(uv_signal_t* handle,
    */
   first_handle = uv__signal_first_handle(signum);
   if (first_handle == NULL ||
-      (!oneshot && (first_handle->flags & UV__SIGNAL_ONE_SHOT))) {
+      (!oneshot && (first_handle->flags & UV_SIGNAL_ONE_SHOT))) {
     err = uv__signal_register_handler(signum, oneshot);
     if (err) {
       /* Registering the signal handler failed. Must be an invalid signal. */
@@ -407,7 +407,7 @@ static int uv__signal_start(uv_signal_t* handle,
 
   handle->signum = signum;
   if (oneshot)
-    handle->flags |= UV__SIGNAL_ONE_SHOT;
+    handle->flags |= UV_SIGNAL_ONE_SHOT;
 
   RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle);
 
@@ -464,20 +464,20 @@ static void uv__signal_event(uv_loop_t* loop,
       handle = msg->handle;
 
       if (msg->signum == handle->signum) {
-        assert(!(handle->flags & UV_CLOSING));
+        assert(!(handle->flags & UV_HANDLE_CLOSING));
         handle->signal_cb(handle, handle->signum);
       }
 
       handle->dispatched_signals++;
 
-      if (handle->flags & UV__SIGNAL_ONE_SHOT)
+      if (handle->flags & UV_SIGNAL_ONE_SHOT)
         uv__signal_stop(handle);
 
       /* If uv_close was called while there were caught signals that were not
        * yet dispatched, the uv__finish_close was deferred. Make close pending
        * now if this has happened.
        */
-      if ((handle->flags & UV_CLOSING) &&
+      if ((handle->flags & UV_HANDLE_CLOSING) &&
           (handle->caught_signals == handle->dispatched_signals)) {
         uv__make_close_pending((uv_handle_t*) handle);
       }
@@ -505,11 +505,11 @@ static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
   if (w1->signum < w2->signum) return -1;
   if (w1->signum > w2->signum) return 1;
 
-  /* Handlers without UV__SIGNAL_ONE_SHOT set will come first, so if the first
+  /* Handlers without UV_SIGNAL_ONE_SHOT set will come first, so if the first
    * handler returned is a one-shot handler, the rest will be too.
    */
-  f1 = w1->flags & UV__SIGNAL_ONE_SHOT;
-  f2 = w2->flags & UV__SIGNAL_ONE_SHOT;
+  f1 = w1->flags & UV_SIGNAL_ONE_SHOT;
+  f2 = w2->flags & UV_SIGNAL_ONE_SHOT;
   if (f1 < f2) return -1;
   if (f1 > f2) return 1;
 
@@ -558,8 +558,8 @@ static void uv__signal_stop(uv_signal_t* handle) {
   if (first_handle == NULL) {
     uv__signal_unregister_handler(handle->signum);
   } else {
-    rem_oneshot = handle->flags & UV__SIGNAL_ONE_SHOT;
-    first_oneshot = first_handle->flags & UV__SIGNAL_ONE_SHOT;
+    rem_oneshot = handle->flags & UV_SIGNAL_ONE_SHOT;
+    first_oneshot = first_handle->flags & UV_SIGNAL_ONE_SHOT;
     if (first_oneshot && !rem_oneshot) {
       ret = uv__signal_register_handler(handle->signum, 1);
       assert(ret == 0);
diff --git a/deps/uv/src/unix/stream.c b/deps/uv/src/unix/stream.c
index fb56a06b43e3be..4d62a23f1b9b7a 100644
--- a/deps/uv/src/unix/stream.c
+++ b/deps/uv/src/unix/stream.c
@@ -220,7 +220,7 @@ static void uv__stream_osx_select(void* arg) {
       uv_sem_wait(&s->async_sem);
 
       /* Should be processed at this stage */
-      assert((s->events == 0) || (stream->flags & UV_CLOSING));
+      assert((s->events == 0) || (stream->flags & UV_HANDLE_CLOSING));
     }
   }
 }
@@ -248,7 +248,7 @@ static void uv__stream_osx_select_cb(uv_async_t* handle) {
   if ((events & POLLOUT) && uv__io_active(&stream->io_watcher, POLLOUT))
     uv__stream_io(stream->loop, &stream->io_watcher, POLLOUT);
 
-  if (stream->flags & UV_CLOSING)
+  if (stream->flags & UV_HANDLE_CLOSING)
     return;
 
   /* NOTE: It is important to do it here, otherwise `select()` might be called
@@ -342,7 +342,7 @@ int uv__stream_try_select(uv_stream_t* stream, int* fd) {
   if (err)
     goto failed_async_init;
 
-  s->async.flags |= UV__HANDLE_INTERNAL;
+  s->async.flags |= UV_HANDLE_INTERNAL;
   uv__handle_unref(&s->async);
 
   err = uv_sem_init(&s->close_sem, 0);
@@ -407,12 +407,14 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
   stream->flags |= flags;
 
   if (stream->type == UV_TCP) {
-    if ((stream->flags & UV_TCP_NODELAY) && uv__tcp_nodelay(fd, 1))
+    if ((stream->flags & UV_HANDLE_TCP_NODELAY) && uv__tcp_nodelay(fd, 1))
       return UV__ERR(errno);
 
     /* TODO Use delay the user passed in. */
-    if ((stream->flags & UV_TCP_KEEPALIVE) && uv__tcp_keepalive(fd, 1, 60))
+    if ((stream->flags & UV_HANDLE_TCP_KEEPALIVE) &&
+        uv__tcp_keepalive(fd, 1, 60)) {
       return UV__ERR(errno);
+    }
   }
 
 #if defined(__APPLE__)
@@ -447,7 +449,7 @@ void uv__stream_flush_write_queue(uv_stream_t* stream, int error) {
 
 void uv__stream_destroy(uv_stream_t* stream) {
   assert(!uv__io_active(&stream->io_watcher, POLLIN | POLLOUT));
-  assert(stream->flags & UV_CLOSED);
+  assert(stream->flags & UV_HANDLE_CLOSED);
 
   if (stream->connect_req) {
     uv__req_unregister(stream->loop, stream->connect_req);
@@ -522,7 +524,7 @@ void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
   stream = container_of(w, uv_stream_t, io_watcher);
   assert(events & POLLIN);
   assert(stream->accepted_fd == -1);
-  assert(!(stream->flags & UV_CLOSING));
+  assert(!(stream->flags & UV_HANDLE_CLOSING));
 
   uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
 
@@ -565,7 +567,8 @@ void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
       return;
     }
 
-    if (stream->type == UV_TCP && (stream->flags & UV_TCP_SINGLE_ACCEPT)) {
+    if (stream->type == UV_TCP &&
+        (stream->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
       /* Give other processes a chance to accept connections. */
       struct timespec timeout = { 0, 1 };
       nanosleep(&timeout, NULL);
@@ -590,7 +593,7 @@ int uv_accept(uv_stream_t* server, uv_stream_t* client) {
     case UV_TCP:
       err = uv__stream_open(client,
                             server->accepted_fd,
-                            UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+                            UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
       if (err) {
         /* TODO handle error */
         uv__close(server->accepted_fd);
@@ -674,14 +677,14 @@ static void uv__drain(uv_stream_t* stream) {
   uv__stream_osx_interrupt_select(stream);
 
   /* Shutdown? */
-  if ((stream->flags & UV_STREAM_SHUTTING) &&
-      !(stream->flags & UV_CLOSING) &&
-      !(stream->flags & UV_STREAM_SHUT)) {
+  if ((stream->flags & UV_HANDLE_SHUTTING) &&
+      !(stream->flags & UV_HANDLE_CLOSING) &&
+      !(stream->flags & UV_HANDLE_SHUT)) {
     assert(stream->shutdown_req);
 
     req = stream->shutdown_req;
     stream->shutdown_req = NULL;
-    stream->flags &= ~UV_STREAM_SHUTTING;
+    stream->flags &= ~UV_HANDLE_SHUTTING;
     uv__req_unregister(stream->loop, req);
 
     err = 0;
@@ -689,7 +692,7 @@ static void uv__drain(uv_stream_t* stream) {
       err = UV__ERR(errno);
 
     if (err == 0)
-      stream->flags |= UV_STREAM_SHUT;
+      stream->flags |= UV_HANDLE_SHUT;
 
     if (req->cb != NULL)
       req->cb(req, err);
@@ -868,7 +871,7 @@ static void uv__write(uv_stream_t* stream) {
     if (!WRITE_RETRY_ON_ERROR(req->send_handle)) {
       err = UV__ERR(errno);
       goto error;
-    } else if (stream->flags & UV_STREAM_BLOCKING) {
+    } else if (stream->flags & UV_HANDLE_BLOCKING_WRITES) {
       /* If this is a blocking stream, try again. */
       goto start;
     }
@@ -888,7 +891,7 @@ static void uv__write(uv_stream_t* stream) {
         n = 0;
 
         /* There is more to write. */
-        if (stream->flags & UV_STREAM_BLOCKING) {
+        if (stream->flags & UV_HANDLE_BLOCKING_WRITES) {
           /*
            * If we're blocking then we should not be enabling the write
            * watcher - instead we need to try again.
@@ -924,7 +927,7 @@ static void uv__write(uv_stream_t* stream) {
   assert(n == 0 || n == -1);
 
   /* Only non-blocking streams should use the write_watcher. */
-  assert(!(stream->flags & UV_STREAM_BLOCKING));
+  assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
 
   /* We're not done. */
   uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
@@ -1015,13 +1018,13 @@ uv_handle_type uv__handle_type(int fd) {
 
 
 static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) {
-  stream->flags |= UV_STREAM_READ_EOF;
+  stream->flags |= UV_HANDLE_READ_EOF;
   uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
   if (!uv__io_active(&stream->io_watcher, POLLOUT))
     uv__handle_stop(stream);
   uv__stream_osx_interrupt_select(stream);
   stream->read_cb(stream, UV_EOF, buf);
-  stream->flags &= ~UV_STREAM_READING;
+  stream->flags &= ~UV_HANDLE_READING;
 }
 
 
@@ -1133,7 +1136,7 @@ static void uv__read(uv_stream_t* stream) {
   int err;
   int is_ipc;
 
-  stream->flags &= ~UV_STREAM_READ_PARTIAL;
+  stream->flags &= ~UV_HANDLE_READ_PARTIAL;
 
   /* Prevent loop starvation when the data comes in as fast as (or faster than)
    * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
@@ -1142,11 +1145,11 @@ static void uv__read(uv_stream_t* stream) {
 
   is_ipc = stream->type == UV_NAMED_PIPE && ((uv_pipe_t*) stream)->ipc;
 
-  /* XXX: Maybe instead of having UV_STREAM_READING we just test if
+  /* XXX: Maybe instead of having UV_HANDLE_READING we just test if
    * tcp->read_cb is NULL or not?
    */
   while (stream->read_cb
-      && (stream->flags & UV_STREAM_READING)
+      && (stream->flags & UV_HANDLE_READING)
       && (count-- > 0)) {
     assert(stream->alloc_cb != NULL);
 
@@ -1187,7 +1190,7 @@ static void uv__read(uv_stream_t* stream) {
       /* Error */
       if (errno == EAGAIN || errno == EWOULDBLOCK) {
         /* Wait for the next one. */
-        if (stream->flags & UV_STREAM_READING) {
+        if (stream->flags & UV_HANDLE_READING) {
           uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
           uv__stream_osx_interrupt_select(stream);
         }
@@ -1200,8 +1203,8 @@ static void uv__read(uv_stream_t* stream) {
       } else {
         /* Error. User should call uv_close(). */
         stream->read_cb(stream, UV__ERR(errno), &buf);
-        if (stream->flags & UV_STREAM_READING) {
-          stream->flags &= ~UV_STREAM_READING;
+        if (stream->flags & UV_HANDLE_READING) {
+          stream->flags &= ~UV_HANDLE_READING;
           uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
           if (!uv__io_active(&stream->io_watcher, POLLOUT))
             uv__handle_stop(stream);
@@ -1251,7 +1254,7 @@ static void uv__read(uv_stream_t* stream) {
 
       /* Return if we didn't fill the buffer, there is no more data to read. */
       if (nread < buflen) {
-        stream->flags |= UV_STREAM_READ_PARTIAL;
+        stream->flags |= UV_HANDLE_READ_PARTIAL;
         return;
       }
     }
@@ -1272,9 +1275,9 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
          stream->type == UV_TTY ||
          stream->type == UV_NAMED_PIPE);
 
-  if (!(stream->flags & UV_STREAM_WRITABLE) ||
-      stream->flags & UV_STREAM_SHUT ||
-      stream->flags & UV_STREAM_SHUTTING ||
+  if (!(stream->flags & UV_HANDLE_WRITABLE) ||
+      stream->flags & UV_HANDLE_SHUT ||
+      stream->flags & UV_HANDLE_SHUTTING ||
       uv__is_closing(stream)) {
     return UV_ENOTCONN;
   }
@@ -1286,7 +1289,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
   req->handle = stream;
   req->cb = cb;
   stream->shutdown_req = req;
-  stream->flags |= UV_STREAM_SHUTTING;
+  stream->flags |= UV_HANDLE_SHUTTING;
 
   uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
   uv__stream_osx_interrupt_select(stream);
@@ -1303,7 +1306,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
   assert(stream->type == UV_TCP ||
          stream->type == UV_NAMED_PIPE ||
          stream->type == UV_TTY);
-  assert(!(stream->flags & UV_CLOSING));
+  assert(!(stream->flags & UV_HANDLE_CLOSING));
 
   if (stream->connect_req) {
     uv__stream_connect(stream);
@@ -1326,9 +1329,9 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
    * report the EOF yet because there is still data to read.
    */
   if ((events & POLLHUP) &&
-      (stream->flags & UV_STREAM_READING) &&
-      (stream->flags & UV_STREAM_READ_PARTIAL) &&
-      !(stream->flags & UV_STREAM_READ_EOF)) {
+      (stream->flags & UV_HANDLE_READING) &&
+      (stream->flags & UV_HANDLE_READ_PARTIAL) &&
+      !(stream->flags & UV_HANDLE_READ_EOF)) {
     uv_buf_t buf = { NULL, 0 };
     uv__stream_eof(stream, &buf);
   }
@@ -1418,7 +1421,7 @@ int uv_write2(uv_write_t* req,
   if (uv__stream_fd(stream) < 0)
     return UV_EBADF;
 
-  if (!(stream->flags & UV_STREAM_WRITABLE))
+  if (!(stream->flags & UV_HANDLE_WRITABLE))
     return -EPIPE;
 
   if (send_handle) {
@@ -1488,7 +1491,7 @@ int uv_write2(uv_write_t* req,
      * if this assert fires then somehow the blocking stream isn't being
      * sufficiently flushed in uv__write.
      */
-    assert(!(stream->flags & UV_STREAM_BLOCKING));
+    assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
     uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
     uv__stream_osx_interrupt_select(stream);
   }
@@ -1569,16 +1572,16 @@ int uv_read_start(uv_stream_t* stream,
   assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
       stream->type == UV_TTY);
 
-  if (stream->flags & UV_CLOSING)
+  if (stream->flags & UV_HANDLE_CLOSING)
     return UV_EINVAL;
 
-  if (!(stream->flags & UV_STREAM_READABLE))
+  if (!(stream->flags & UV_HANDLE_READABLE))
     return -ENOTCONN;
 
-  /* The UV_STREAM_READING flag is irrelevant of the state of the tcp - it just
+  /* The UV_HANDLE_READING flag is irrelevant of the state of the tcp - it just
    * expresses the desired state of the user.
    */
-  stream->flags |= UV_STREAM_READING;
+  stream->flags |= UV_HANDLE_READING;
 
   /* TODO: try to do the read inline? */
   /* TODO: keep track of tcp state. If we've gotten a EOF then we should
@@ -1599,10 +1602,10 @@ int uv_read_start(uv_stream_t* stream,
 
 
 int uv_read_stop(uv_stream_t* stream) {
-  if (!(stream->flags & UV_STREAM_READING))
+  if (!(stream->flags & UV_HANDLE_READING))
     return 0;
 
-  stream->flags &= ~UV_STREAM_READING;
+  stream->flags &= ~UV_HANDLE_READING;
   uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
   if (!uv__io_active(&stream->io_watcher, POLLOUT))
     uv__handle_stop(stream);
@@ -1615,12 +1618,12 @@ int uv_read_stop(uv_stream_t* stream) {
 
 
 int uv_is_readable(const uv_stream_t* stream) {
-  return !!(stream->flags & UV_STREAM_READABLE);
+  return !!(stream->flags & UV_HANDLE_READABLE);
 }
 
 
 int uv_is_writable(const uv_stream_t* stream) {
-  return !!(stream->flags & UV_STREAM_WRITABLE);
+  return !!(stream->flags & UV_HANDLE_WRITABLE);
 }
 
 
diff --git a/deps/uv/src/unix/tcp.c b/deps/uv/src/unix/tcp.c
index 27a2a6130cba1d..2982851dc6eaa1 100644
--- a/deps/uv/src/unix/tcp.c
+++ b/deps/uv/src/unix/tcp.c
@@ -216,7 +216,7 @@ int uv__tcp_connect(uv_connect_t* req,
 
   err = maybe_new_socket(handle,
                          addr->sa_family,
-                         UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
   if (err)
     return err;
 
@@ -272,7 +272,7 @@ int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
 
   return uv__stream_open((uv_stream_t*)handle,
                          sock,
-                         UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
 }
 
 
@@ -334,7 +334,7 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
   }
 
   if (single_accept)
-    tcp->flags |= UV_TCP_SINGLE_ACCEPT;
+    tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
 
   flags = 0;
 #if defined(__MVS__)
@@ -401,9 +401,9 @@ int uv_tcp_nodelay(uv_tcp_t* handle, int on) {
   }
 
   if (on)
-    handle->flags |= UV_TCP_NODELAY;
+    handle->flags |= UV_HANDLE_TCP_NODELAY;
   else
-    handle->flags &= ~UV_TCP_NODELAY;
+    handle->flags &= ~UV_HANDLE_TCP_NODELAY;
 
   return 0;
 }
@@ -419,9 +419,9 @@ int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
   }
 
   if (on)
-    handle->flags |= UV_TCP_KEEPALIVE;
+    handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
   else
-    handle->flags &= ~UV_TCP_KEEPALIVE;
+    handle->flags &= ~UV_HANDLE_TCP_KEEPALIVE;
 
   /* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge
    *      uv_tcp_t with an int that's almost never used...
@@ -433,9 +433,9 @@ int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
 
 int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) {
   if (enable)
-    handle->flags &= ~UV_TCP_SINGLE_ACCEPT;
+    handle->flags &= ~UV_HANDLE_TCP_SINGLE_ACCEPT;
   else
-    handle->flags |= UV_TCP_SINGLE_ACCEPT;
+    handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
   return 0;
 }
 
diff --git a/deps/uv/src/unix/tty.c b/deps/uv/src/unix/tty.c
index f22b3b80de061f..1b92b5c914ce9e 100644
--- a/deps/uv/src/unix/tty.c
+++ b/deps/uv/src/unix/tty.c
@@ -135,7 +135,7 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int readable) {
     if (r < 0) {
       /* fallback to using blocking writes */
       if (!readable)
-        flags |= UV_STREAM_BLOCKING;
+        flags |= UV_HANDLE_BLOCKING_WRITES;
       goto skip;
     }
 
@@ -177,7 +177,7 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int readable) {
    * the handle queue, since it was added by uv__handle_init in uv_stream_init.
    */
 
-  if (!(flags & UV_STREAM_BLOCKING))
+  if (!(flags & UV_HANDLE_BLOCKING_WRITES))
     uv__nonblock(fd, 1);
 
 #if defined(__APPLE__)
@@ -195,9 +195,9 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int readable) {
 #endif
 
   if (readable)
-    flags |= UV_STREAM_READABLE;
+    flags |= UV_HANDLE_READABLE;
   else
-    flags |= UV_STREAM_WRITABLE;
+    flags |= UV_HANDLE_WRITABLE;
 
   uv__stream_open((uv_stream_t*) tty, fd, flags);
   tty->mode = UV_TTY_MODE_NORMAL;
diff --git a/deps/uv/src/unix/udp.c b/deps/uv/src/unix/udp.c
index 15da047a5c5fbc..e6668a012c5c27 100644
--- a/deps/uv/src/unix/udp.c
+++ b/deps/uv/src/unix/udp.c
@@ -92,8 +92,8 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
   uv_udp_send_t* req;
   QUEUE* q;
 
-  assert(!(handle->flags & UV_UDP_PROCESSING));
-  handle->flags |= UV_UDP_PROCESSING;
+  assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
+  handle->flags |= UV_HANDLE_UDP_PROCESSING;
 
   while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
     q = QUEUE_HEAD(&handle->write_completed_queue);
@@ -128,7 +128,7 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
       uv__handle_stop(handle);
   }
 
-  handle->flags &= ~UV_UDP_PROCESSING;
+  handle->flags &= ~UV_HANDLE_UDP_PROCESSING;
 }
 
 
@@ -427,7 +427,7 @@ int uv__udp_send(uv_udp_send_t* req,
   QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
   uv__handle_start(handle);
 
-  if (empty_queue && !(handle->flags & UV_UDP_PROCESSING)) {
+  if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
     uv__udp_sendmsg(handle);
 
     /* `uv__udp_sendmsg` may not be able to do non-blocking write straight
diff --git a/deps/uv/src/uv-common.c b/deps/uv/src/uv-common.c
index 71345895697732..f0aec452606cb8 100644
--- a/deps/uv/src/uv-common.c
+++ b/deps/uv/src/uv-common.c
@@ -155,6 +155,18 @@ static const char* uv__unknown_err_code(int err) {
   return copy != NULL ? copy : "Unknown system error";
 }
 
+#define UV_ERR_NAME_GEN_R(name, _) \
+case UV_## name: \
+  snprintf(buf, buflen, "%s", #name); break;
+char* uv_err_name_r(int err, char* buf, size_t buflen) {
+  switch (err) {
+    UV_ERRNO_MAP(UV_ERR_NAME_GEN_R)
+    default: snprintf(buf, buflen, "Unknown system error %d", err);
+  }
+  return buf;
+}
+#undef UV_ERR_NAME_GEN_R
+
 
 #define UV_ERR_NAME_GEN(name, _) case UV_ ## name: return #name;
 const char* uv_err_name(int err) {
@@ -166,6 +178,19 @@ const char* uv_err_name(int err) {
 #undef UV_ERR_NAME_GEN
 
 
+#define UV_STRERROR_GEN_R(name, msg) \
+case UV_ ## name: \
+  snprintf(buf, buflen, "%s", msg); break;
+char* uv_strerror_r(int err, char* buf, size_t buflen) {
+  switch (err) {
+    UV_ERRNO_MAP(UV_STRERROR_GEN_R)
+    default: snprintf(buf, buflen, "Unknown system error %d", err);
+  }
+  return buf;
+}
+#undef UV_STRERROR_GEN_R
+
+
 #define UV_STRERROR_GEN(name, msg) case UV_ ## name: return msg;
 const char* uv_strerror(int err) {
   switch (err) {
@@ -357,7 +382,7 @@ void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
     QUEUE_REMOVE(q);
     QUEUE_INSERT_TAIL(&loop->handle_queue, q);
 
-    if (h->flags & UV__HANDLE_INTERNAL) continue;
+    if (h->flags & UV_HANDLE_INTERNAL) continue;
     walk_cb(h, arg);
   }
 }
@@ -386,9 +411,9 @@ static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) {
 
     fprintf(stream,
             "[%c%c%c] %-8s %p\n",
-            "R-"[!(h->flags & UV__HANDLE_REF)],
-            "A-"[!(h->flags & UV__HANDLE_ACTIVE)],
-            "I-"[!(h->flags & UV__HANDLE_INTERNAL)],
+            "R-"[!(h->flags & UV_HANDLE_REF)],
+            "A-"[!(h->flags & UV_HANDLE_ACTIVE)],
+            "I-"[!(h->flags & UV_HANDLE_INTERNAL)],
             type,
             (void*)h);
   }
@@ -632,7 +657,7 @@ int uv_loop_close(uv_loop_t* loop) {
 
   QUEUE_FOREACH(q, &loop->handle_queue) {
     h = QUEUE_DATA(q, uv_handle_t, handle_queue);
-    if (!(h->flags & UV__HANDLE_INTERNAL))
+    if (!(h->flags & UV_HANDLE_INTERNAL))
       return UV_EBUSY;
   }
 
diff --git a/deps/uv/src/uv-common.h b/deps/uv/src/uv-common.h
index 85bcbe6c8adece..3289950d009ccd 100644
--- a/deps/uv/src/uv-common.h
+++ b/deps/uv/src/uv-common.h
@@ -59,22 +59,67 @@ extern int snprintf(char*, size_t, const char*, ...);
 #define STATIC_ASSERT(expr)                                                   \
   void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])
 
-#ifndef _WIN32
+/* Handle flags. Some flags are specific to Windows or UNIX. */
 enum {
-  UV__SIGNAL_ONE_SHOT = 0x80000,  /* On signal reception remove sighandler */
-  UV__HANDLE_INTERNAL = 0x8000,
-  UV__HANDLE_ACTIVE   = 0x4000,
-  UV__HANDLE_REF      = 0x2000,
-  UV__HANDLE_CLOSING  = 0 /* no-op on unix */
+  /* Used by all handles. */
+  UV_HANDLE_CLOSING                     = 0x00000001,
+  UV_HANDLE_CLOSED                      = 0x00000002,
+  UV_HANDLE_ACTIVE                      = 0x00000004,
+  UV_HANDLE_REF                         = 0x00000008,
+  UV_HANDLE_INTERNAL                    = 0x00000010,
+  UV_HANDLE_ENDGAME_QUEUED              = 0x00000020,
+
+  /* Used by streams. */
+  UV_HANDLE_LISTENING                   = 0x00000040,
+  UV_HANDLE_CONNECTION                  = 0x00000080,
+  UV_HANDLE_SHUTTING                    = 0x00000100,
+  UV_HANDLE_SHUT                        = 0x00000200,
+  UV_HANDLE_READ_PARTIAL                = 0x00000400,
+  UV_HANDLE_READ_EOF                    = 0x00000800,
+
+  /* Used by streams and UDP handles. */
+  UV_HANDLE_READING                     = 0x00001000,
+  UV_HANDLE_BOUND                       = 0x00002000,
+  UV_HANDLE_READABLE                    = 0x00004000,
+  UV_HANDLE_WRITABLE                    = 0x00008000,
+  UV_HANDLE_READ_PENDING                = 0x00010000,
+  UV_HANDLE_SYNC_BYPASS_IOCP            = 0x00020000,
+  UV_HANDLE_ZERO_READ                   = 0x00040000,
+  UV_HANDLE_EMULATE_IOCP                = 0x00080000,
+  UV_HANDLE_BLOCKING_WRITES             = 0x00100000,
+  UV_HANDLE_CANCELLATION_PENDING        = 0x00200000,
+
+  /* Used by uv_tcp_t and uv_udp_t handles */
+  UV_HANDLE_IPV6                        = 0x00400000,
+
+  /* Only used by uv_tcp_t handles. */
+  UV_HANDLE_TCP_NODELAY                 = 0x01000000,
+  UV_HANDLE_TCP_KEEPALIVE               = 0x02000000,
+  UV_HANDLE_TCP_SINGLE_ACCEPT           = 0x04000000,
+  UV_HANDLE_TCP_ACCEPT_STATE_CHANGING   = 0x08000000,
+  UV_HANDLE_TCP_SOCKET_CLOSED           = 0x10000000,
+  UV_HANDLE_SHARED_TCP_SOCKET           = 0x20000000,
+
+  /* Only used by uv_udp_t handles. */
+  UV_HANDLE_UDP_PROCESSING              = 0x01000000,
+
+  /* Only used by uv_pipe_t handles. */
+  UV_HANDLE_NON_OVERLAPPED_PIPE         = 0x01000000,
+  UV_HANDLE_PIPESERVER                  = 0x02000000,
+
+  /* Only used by uv_tty_t handles. */
+  UV_HANDLE_TTY_READABLE                = 0x01000000,
+  UV_HANDLE_TTY_RAW                     = 0x02000000,
+  UV_HANDLE_TTY_SAVED_POSITION          = 0x04000000,
+  UV_HANDLE_TTY_SAVED_ATTRIBUTES        = 0x08000000,
+
+  /* Only used by uv_signal_t handles. */
+  UV_SIGNAL_ONE_SHOT_DISPATCHED         = 0x01000000,
+  UV_SIGNAL_ONE_SHOT                    = 0x02000000,
+
+  /* Only used by uv_poll_t handles. */
+  UV_HANDLE_POLL_SLOW                   = 0x01000000
 };
-#else
-# define UV__SIGNAL_ONE_SHOT_DISPATCHED   0x200
-# define UV__SIGNAL_ONE_SHOT              0x100
-# define UV__HANDLE_INTERNAL              0x80
-# define UV__HANDLE_ACTIVE                0x40
-# define UV__HANDLE_REF                   0x20
-# define UV__HANDLE_CLOSING               0x01
-#endif
 
 int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap);
 
@@ -132,6 +177,10 @@ int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value);
 
 void uv__fs_scandir_cleanup(uv_fs_t* req);
 
+int uv__next_timeout(const uv_loop_t* loop);
+void uv__run_timers(uv_loop_t* loop);
+void uv__timer_close(uv_timer_t* handle);
+
 #define uv__has_active_reqs(loop)                                             \
   ((loop)->active_reqs.count > 0)
 
@@ -164,49 +213,47 @@ void uv__fs_scandir_cleanup(uv_fs_t* req);
   while (0)
 
 #define uv__is_active(h)                                                      \
-  (((h)->flags & UV__HANDLE_ACTIVE) != 0)
+  (((h)->flags & UV_HANDLE_ACTIVE) != 0)
 
 #define uv__is_closing(h)                                                     \
-  (((h)->flags & (UV_CLOSING |  UV_CLOSED)) != 0)
+  (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)
 
 #define uv__handle_start(h)                                                   \
   do {                                                                        \
-    assert(((h)->flags & UV__HANDLE_CLOSING) == 0);                           \
-    if (((h)->flags & UV__HANDLE_ACTIVE) != 0) break;                         \
-    (h)->flags |= UV__HANDLE_ACTIVE;                                          \
-    if (((h)->flags & UV__HANDLE_REF) != 0) uv__active_handle_add(h);         \
+    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break;                          \
+    (h)->flags |= UV_HANDLE_ACTIVE;                                           \
+    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_add(h);          \
   }                                                                           \
   while (0)
 
 #define uv__handle_stop(h)                                                    \
   do {                                                                        \
-    assert(((h)->flags & UV__HANDLE_CLOSING) == 0);                           \
-    if (((h)->flags & UV__HANDLE_ACTIVE) == 0) break;                         \
-    (h)->flags &= ~UV__HANDLE_ACTIVE;                                         \
-    if (((h)->flags & UV__HANDLE_REF) != 0) uv__active_handle_rm(h);          \
+    if (((h)->flags & UV_HANDLE_ACTIVE) == 0) break;                          \
+    (h)->flags &= ~UV_HANDLE_ACTIVE;                                          \
+    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_rm(h);           \
   }                                                                           \
   while (0)
 
 #define uv__handle_ref(h)                                                     \
   do {                                                                        \
-    if (((h)->flags & UV__HANDLE_REF) != 0) break;                            \
-    (h)->flags |= UV__HANDLE_REF;                                             \
-    if (((h)->flags & UV__HANDLE_CLOSING) != 0) break;                        \
-    if (((h)->flags & UV__HANDLE_ACTIVE) != 0) uv__active_handle_add(h);      \
+    if (((h)->flags & UV_HANDLE_REF) != 0) break;                             \
+    (h)->flags |= UV_HANDLE_REF;                                              \
+    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
+    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_add(h);       \
   }                                                                           \
   while (0)
 
 #define uv__handle_unref(h)                                                   \
   do {                                                                        \
-    if (((h)->flags & UV__HANDLE_REF) == 0) break;                            \
-    (h)->flags &= ~UV__HANDLE_REF;                                            \
-    if (((h)->flags & UV__HANDLE_CLOSING) != 0) break;                        \
-    if (((h)->flags & UV__HANDLE_ACTIVE) != 0) uv__active_handle_rm(h);       \
+    if (((h)->flags & UV_HANDLE_REF) == 0) break;                             \
+    (h)->flags &= ~UV_HANDLE_REF;                                             \
+    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
+    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_rm(h);        \
   }                                                                           \
   while (0)
 
 #define uv__has_ref(h)                                                        \
-  (((h)->flags & UV__HANDLE_REF) != 0)
+  (((h)->flags & UV_HANDLE_REF) != 0)
 
 #if defined(_WIN32)
 # define uv__handle_platform_init(h) ((h)->u.fd = -1)
@@ -218,7 +265,7 @@ void uv__fs_scandir_cleanup(uv_fs_t* req);
   do {                                                                        \
     (h)->loop = (loop_);                                                      \
     (h)->type = (type_);                                                      \
-    (h)->flags = UV__HANDLE_REF;  /* Ref the loop when active. */             \
+    (h)->flags = UV_HANDLE_REF;  /* Ref the loop when active. */              \
     QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue);            \
     uv__handle_platform_init(h);                                              \
   }                                                                           \
diff --git a/deps/uv/src/win/async.c b/deps/uv/src/win/async.c
index 13d3c7b33e48af..d787f6604eaedd 100644
--- a/deps/uv/src/win/async.c
+++ b/deps/uv/src/win/async.c
@@ -29,7 +29,7 @@
 
 
 void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) {
-  if (handle->flags & UV__HANDLE_CLOSING &&
+  if (handle->flags & UV_HANDLE_CLOSING &&
       !handle->async_sent) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     uv__handle_close(handle);
@@ -73,7 +73,7 @@ int uv_async_send(uv_async_t* handle) {
 
   /* The user should make sure never to call uv_async_send to a closing or
    * closed handle. */
-  assert(!(handle->flags & UV__HANDLE_CLOSING));
+  assert(!(handle->flags & UV_HANDLE_CLOSING));
 
   if (!uv__atomic_exchange_set(&handle->async_sent)) {
     POST_COMPLETION_FOR_REQ(loop, &handle->async_req);
@@ -90,7 +90,7 @@ void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
 
   handle->async_sent = 0;
 
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     uv_want_endgame(loop, (uv_handle_t*)handle);
   } else if (handle->async_cb != NULL) {
     handle->async_cb(handle);
diff --git a/deps/uv/src/win/core.c b/deps/uv/src/win/core.c
index d6af282a2999ee..5a76c900337c3d 100644
--- a/deps/uv/src/win/core.c
+++ b/deps/uv/src/win/core.c
@@ -33,6 +33,7 @@
 #include "internal.h"
 #include "queue.h"
 #include "handle-inl.h"
+#include "heap-inl.h"
 #include "req-inl.h"
 
 /* uv_once initialization guards */
@@ -221,6 +222,7 @@ static void uv_init(void) {
 
 
 int uv_loop_init(uv_loop_t* loop) {
+  struct heap* timer_heap;
   int err;
 
   /* Initialize libuv itself first */
@@ -246,7 +248,11 @@ int uv_loop_init(uv_loop_t* loop) {
 
   loop->endgame_handles = NULL;
 
-  RB_INIT(&loop->timers);
+  loop->timer_heap = timer_heap = uv__malloc(sizeof(*timer_heap));
+  if (timer_heap == NULL)
+    goto fail_timers_alloc;
+
+  heap_init(timer_heap);
 
   loop->check_handles = NULL;
   loop->prepare_handles = NULL;
@@ -273,7 +279,7 @@ int uv_loop_init(uv_loop_t* loop) {
     goto fail_async_init;
 
   uv__handle_unref(&loop->wq_async);
-  loop->wq_async.flags |= UV__HANDLE_INTERNAL;
+  loop->wq_async.flags |= UV_HANDLE_INTERNAL;
 
   err = uv__loops_add(loop);
   if (err)
@@ -285,6 +291,10 @@ int uv_loop_init(uv_loop_t* loop) {
   uv_mutex_destroy(&loop->wq_mutex);
 
 fail_mutex_init:
+  uv__free(timer_heap);
+  loop->timer_heap = NULL;
+
+fail_timers_alloc:
   CloseHandle(loop->iocp);
   loop->iocp = INVALID_HANDLE_VALUE;
 
@@ -292,6 +302,13 @@ int uv_loop_init(uv_loop_t* loop) {
 }
 
 
+void uv_update_time(uv_loop_t* loop) {
+  uint64_t new_time = uv__hrtime(1000);
+  assert(new_time >= loop->time);
+  loop->time = new_time;
+}
+
+
 void uv__once_init(void) {
   uv_once(&uv_init_guard_, uv_init);
 }
@@ -320,6 +337,9 @@ void uv__loop_close(uv_loop_t* loop) {
   uv_mutex_unlock(&loop->wq_mutex);
   uv_mutex_destroy(&loop->wq_mutex);
 
+  uv__free(loop->timer_heap);
+  loop->timer_heap = NULL;
+
   CloseHandle(loop->iocp);
 }
 
@@ -441,7 +461,7 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) {
 
   while (r != 0 && loop->stop_flag == 0) {
     uv_update_time(loop);
-    uv_process_timers(loop);
+    uv__run_timers(loop);
 
     ran_pending = uv_process_reqs(loop);
     uv_idle_invoke(loop);
@@ -465,7 +485,7 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) {
        * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
        * the check.
        */
-      uv_process_timers(loop);
+      uv__run_timers(loop);
     }
 
     r = uv__loop_alive(loop);
diff --git a/deps/uv/src/win/fs-event.c b/deps/uv/src/win/fs-event.c
index 14c9af9ad754d6..226e6e7aee6c09 100644
--- a/deps/uv/src/win/fs-event.c
+++ b/deps/uv/src/win/fs-event.c
@@ -419,7 +419,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
    * - We are not active, just ignore the callback
    */
   if (!uv__is_active(handle)) {
-    if (handle->flags & UV__HANDLE_CLOSING) {
+    if (handle->flags & UV_HANDLE_CLOSING) {
       uv_want_endgame(loop, (uv_handle_t*) handle);
     }
     return;
@@ -543,7 +543,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
         }
 
         offset = file_info->NextEntryOffset;
-      } while (offset && !(handle->flags & UV__HANDLE_CLOSING));
+      } while (offset && !(handle->flags & UV_HANDLE_CLOSING));
     } else {
       handle->cb(handle, NULL, UV_CHANGE, 0);
     }
@@ -552,7 +552,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
     handle->cb(handle, NULL, 0, uv_translate_sys_error(err));
   }
 
-  if (!(handle->flags & UV__HANDLE_CLOSING)) {
+  if (!(handle->flags & UV_HANDLE_CLOSING)) {
     uv_fs_event_queue_readdirchanges(loop, handle);
   } else {
     uv_want_endgame(loop, (uv_handle_t*)handle);
@@ -573,7 +573,7 @@ void uv_fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle) {
 
 
 void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {
-  if ((handle->flags & UV__HANDLE_CLOSING) && !handle->req_pending) {
+  if ((handle->flags & UV_HANDLE_CLOSING) && !handle->req_pending) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
 
     if (handle->buffer) {
diff --git a/deps/uv/src/win/handle-inl.h b/deps/uv/src/win/handle-inl.h
index ed843072dfc026..82c657d579fb04 100644
--- a/deps/uv/src/win/handle-inl.h
+++ b/deps/uv/src/win/handle-inl.h
@@ -32,7 +32,7 @@
 #define DECREASE_ACTIVE_COUNT(loop, handle)                             \
   do {                                                                  \
     if (--(handle)->activecnt == 0 &&                                   \
-        !((handle)->flags & UV__HANDLE_CLOSING)) {                      \
+        !((handle)->flags & UV_HANDLE_CLOSING)) {                       \
       uv__handle_stop((handle));                                        \
     }                                                                   \
     assert((handle)->activecnt >= 0);                                   \
@@ -53,7 +53,7 @@
     assert(handle->reqs_pending > 0);                                   \
     handle->reqs_pending--;                                             \
                                                                         \
-    if (handle->flags & UV__HANDLE_CLOSING &&                           \
+    if (handle->flags & UV_HANDLE_CLOSING &&                            \
         handle->reqs_pending == 0) {                                    \
       uv_want_endgame(loop, (uv_handle_t*)handle);                      \
     }                                                                   \
@@ -62,14 +62,14 @@
 
 #define uv__handle_closing(handle)                                      \
   do {                                                                  \
-    assert(!((handle)->flags & UV__HANDLE_CLOSING));                    \
+    assert(!((handle)->flags & UV_HANDLE_CLOSING));                     \
                                                                         \
-    if (!(((handle)->flags & UV__HANDLE_ACTIVE) &&                      \
-          ((handle)->flags & UV__HANDLE_REF)))                          \
+    if (!(((handle)->flags & UV_HANDLE_ACTIVE) &&                       \
+          ((handle)->flags & UV_HANDLE_REF)))                           \
       uv__active_handle_add((uv_handle_t*) (handle));                   \
                                                                         \
-    (handle)->flags |= UV__HANDLE_CLOSING;                              \
-    (handle)->flags &= ~UV__HANDLE_ACTIVE;                              \
+    (handle)->flags |= UV_HANDLE_CLOSING;                               \
+    (handle)->flags &= ~UV_HANDLE_ACTIVE;                               \
   } while (0)
 
 
@@ -126,7 +126,8 @@ INLINE static void uv_process_endgames(uv_loop_t* loop) {
         break;
 
       case UV_TIMER:
-        uv_timer_endgame(loop, (uv_timer_t*) handle);
+        uv__timer_close((uv_timer_t*) handle);
+        uv__handle_close(handle);
         break;
 
       case UV_PREPARE:
diff --git a/deps/uv/src/win/handle.c b/deps/uv/src/win/handle.c
index 39150702ddcd07..738d7ff3248ab4 100644
--- a/deps/uv/src/win/handle.c
+++ b/deps/uv/src/win/handle.c
@@ -59,15 +59,15 @@ uv_handle_type uv_guess_handle(uv_file file) {
 
 
 int uv_is_active(const uv_handle_t* handle) {
-  return (handle->flags & UV__HANDLE_ACTIVE) &&
-        !(handle->flags & UV__HANDLE_CLOSING);
+  return (handle->flags & UV_HANDLE_ACTIVE) &&
+        !(handle->flags & UV_HANDLE_CLOSING);
 }
 
 
 void uv_close(uv_handle_t* handle, uv_close_cb cb) {
   uv_loop_t* loop = handle->loop;
 
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     assert(0);
     return;
   }
@@ -150,7 +150,7 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
 
 
 int uv_is_closing(const uv_handle_t* handle) {
-  return !!(handle->flags & (UV__HANDLE_CLOSING | UV_HANDLE_CLOSED));
+  return !!(handle->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED));
 }
 
 
diff --git a/deps/uv/src/win/internal.h b/deps/uv/src/win/internal.h
index fa926d9a44986e..b37b4c0c9be59f 100644
--- a/deps/uv/src/win/internal.h
+++ b/deps/uv/src/win/internal.h
@@ -57,69 +57,6 @@ extern UV_THREAD_LOCAL int uv__crt_assert_enabled;
 #define UV_END_DISABLE_CRT_ASSERT()
 #endif
 
-/*
- * Handles
- * (also see handle-inl.h)
- */
-
-/* Used by all handles. */
-#define UV_HANDLE_CLOSED                        0x00000002
-#define UV_HANDLE_ENDGAME_QUEUED                0x00000008
-
-/* uv-common.h: #define UV__HANDLE_CLOSING      0x00000001 */
-/* uv-common.h: #define UV__HANDLE_ACTIVE       0x00000040 */
-/* uv-common.h: #define UV__HANDLE_REF          0x00000020 */
-/* uv-common.h: #define UV_HANDLE_INTERNAL      0x00000080 */
-
-/* Used by streams and UDP handles. */
-#define UV_HANDLE_READING                       0x00000100
-#define UV_HANDLE_BOUND                         0x00000200
-#define UV_HANDLE_LISTENING                     0x00000800
-#define UV_HANDLE_CONNECTION                    0x00001000
-#define UV_HANDLE_READABLE                      0x00008000
-#define UV_HANDLE_WRITABLE                      0x00010000
-#define UV_HANDLE_READ_PENDING                  0x00020000
-#define UV_HANDLE_SYNC_BYPASS_IOCP              0x00040000
-#define UV_HANDLE_ZERO_READ                     0x00080000
-#define UV_HANDLE_EMULATE_IOCP                  0x00100000
-#define UV_HANDLE_BLOCKING_WRITES               0x00200000
-#define UV_HANDLE_CANCELLATION_PENDING          0x00400000
-
-/* Used by uv_tcp_t and uv_udp_t handles */
-#define UV_HANDLE_IPV6                          0x01000000
-
-/* Only used by uv_tcp_t handles. */
-#define UV_HANDLE_TCP_NODELAY                   0x02000000
-#define UV_HANDLE_TCP_KEEPALIVE                 0x04000000
-#define UV_HANDLE_TCP_SINGLE_ACCEPT             0x08000000
-#define UV_HANDLE_TCP_ACCEPT_STATE_CHANGING     0x10000000
-#define UV_HANDLE_TCP_SOCKET_CLOSED             0x20000000
-#define UV_HANDLE_SHARED_TCP_SOCKET             0x40000000
-
-/* Only used by uv_pipe_t handles. */
-#define UV_HANDLE_NON_OVERLAPPED_PIPE           0x01000000
-#define UV_HANDLE_PIPESERVER                    0x02000000
-
-/* Only used by uv_tty_t handles. */
-#define UV_HANDLE_TTY_READABLE                  0x01000000
-#define UV_HANDLE_TTY_RAW                       0x02000000
-#define UV_HANDLE_TTY_SAVED_POSITION            0x04000000
-#define UV_HANDLE_TTY_SAVED_ATTRIBUTES          0x08000000
-
-/* Only used by uv_poll_t handles. */
-#define UV_HANDLE_POLL_SLOW                     0x02000000
-
-
-/*
- * Requests: see req-inl.h
- */
-
-
-/*
- * Streams: see stream-inl.h
- */
-
-
 /*
  * TCP
  */
@@ -246,15 +183,6 @@ int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle);
 void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle);
 
 
-/*
- * Timers
- */
-void uv_timer_endgame(uv_loop_t* loop, uv_timer_t* handle);
-
-DWORD uv__next_timeout(const uv_loop_t* loop);
-void uv_process_timers(uv_loop_t* loop);
-
-
 /*
  * Loop watchers
  */
diff --git a/deps/uv/src/win/loop-watcher.c b/deps/uv/src/win/loop-watcher.c
index 20e4509f838c05..ad7fbea169717f 100644
--- a/deps/uv/src/win/loop-watcher.c
+++ b/deps/uv/src/win/loop-watcher.c
@@ -27,7 +27,7 @@
 
 
 void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle) {
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     handle->flags |= UV_HANDLE_CLOSED;
     uv__handle_close(handle);
diff --git a/deps/uv/src/win/pipe.c b/deps/uv/src/win/pipe.c
index ae569326dd0004..42380f6599a45b 100644
--- a/deps/uv/src/win/pipe.c
+++ b/deps/uv/src/win/pipe.c
@@ -21,7 +21,6 @@
 
 #include <assert.h>
 #include <io.h>
-#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -347,7 +346,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
     /* Clear the shutdown_req field so we don't go here again. */
     handle->stream.conn.shutdown_req = NULL;
 
-    if (handle->flags & UV__HANDLE_CLOSING) {
+    if (handle->flags & UV_HANDLE_CLOSING) {
       UNREGISTER_HANDLE_REQ(loop, handle, req);
 
       /* Already closing. Cancel the shutdown. */
@@ -408,7 +407,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
     }
   }
 
-  if (handle->flags & UV__HANDLE_CLOSING &&
+  if (handle->flags & UV_HANDLE_CLOSING &&
       handle->reqs_pending == 0) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
 
@@ -907,7 +906,7 @@ int uv_pipe_accept(uv_pipe_t* server, uv_stream_t* client) {
     req->next_pending = NULL;
     req->pipeHandle = INVALID_HANDLE_VALUE;
 
-    if (!(server->flags & UV__HANDLE_CLOSING)) {
+    if (!(server->flags & UV_HANDLE_CLOSING)) {
       uv_pipe_queue_accept(loop, server, req, FALSE);
     }
   }
@@ -1294,7 +1293,7 @@ static int uv__pipe_write_data(uv_loop_t* loop,
                                size_t nbufs,
                                uv_stream_t* send_handle,
                                uv_write_cb cb,
-                               bool copy_always) {
+                               int copy_always) {
   int err;
   int result;
   uv_buf_t write_buf;
@@ -1536,7 +1535,7 @@ int uv__pipe_write_ipc(uv_loop_t* loop,
   /* Write buffers. We set the `always_copy` flag, so it is not a problem that
    * some of the written data lives on the stack. */
   err = uv__pipe_write_data(
-      loop, req, handle, bufs, buf_count, send_handle, cb, true);
+      loop, req, handle, bufs, buf_count, send_handle, cb, 1);
 
   /* If we had to heap-allocate the bufs array, free it now. */
   if (bufs != stack_bufs) {
@@ -1561,7 +1560,7 @@ int uv__pipe_write(uv_loop_t* loop,
     /* Non-IPC pipe write: put data on the wire directly. */
     assert(send_handle == NULL);
     return uv__pipe_write_data(
-        loop, req, handle, bufs, nbufs, NULL, cb, false);
+        loop, req, handle, bufs, nbufs, NULL, cb, 0);
   }
 }
 
@@ -1675,7 +1674,7 @@ static DWORD uv__pipe_read_data(uv_loop_t* loop,
 
 
 static DWORD uv__pipe_read_ipc(uv_loop_t* loop, uv_pipe_t* handle) {
-  DWORD* data_remaining = &handle->pipe.conn.ipc_data_frame.payload_remaining;
+  uint32_t* data_remaining = &handle->pipe.conn.ipc_data_frame.payload_remaining;
   int err;
 
   if (*data_remaining > 0) {
@@ -1856,7 +1855,7 @@ void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
 
   assert(handle->type == UV_NAMED_PIPE);
 
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     /* The req->pipeHandle should be freed already in uv_pipe_cleanup(). */
     assert(req->pipeHandle == INVALID_HANDLE_VALUE);
     DECREASE_PENDING_REQ_COUNT(handle);
@@ -1876,7 +1875,7 @@ void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
       CloseHandle(req->pipeHandle);
       req->pipeHandle = INVALID_HANDLE_VALUE;
     }
-    if (!(handle->flags & UV__HANDLE_CLOSING)) {
+    if (!(handle->flags & UV_HANDLE_CLOSING)) {
       uv_pipe_queue_accept(loop, handle, req, FALSE);
     }
   }
diff --git a/deps/uv/src/win/poll.c b/deps/uv/src/win/poll.c
index b1369df3c442d3..77eb071c85a338 100644
--- a/deps/uv/src/win/poll.c
+++ b/deps/uv/src/win/poll.c
@@ -218,7 +218,7 @@ static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
   if ((handle->events & ~(handle->submitted_events_1 |
       handle->submitted_events_2)) != 0) {
     uv__fast_poll_submit_poll_req(loop, handle);
-  } else if ((handle->flags & UV__HANDLE_CLOSING) &&
+  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
              handle->submitted_events_1 == 0 &&
              handle->submitted_events_2 == 0) {
     uv_want_endgame(loop, (uv_handle_t*) handle);
@@ -228,7 +228,7 @@ static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
 
 static int uv__fast_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
   assert(handle->type == UV_POLL);
-  assert(!(handle->flags & UV__HANDLE_CLOSING));
+  assert(!(handle->flags & UV_HANDLE_CLOSING));
   assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT)) == 0);
 
   handle->events = events;
@@ -461,7 +461,7 @@ static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
   if ((handle->events & ~(handle->submitted_events_1 |
       handle->submitted_events_2)) != 0) {
     uv__slow_poll_submit_poll_req(loop, handle);
-  } else if ((handle->flags & UV__HANDLE_CLOSING) &&
+  } else if ((handle->flags & UV_HANDLE_CLOSING) &&
              handle->submitted_events_1 == 0 &&
              handle->submitted_events_2 == 0) {
     uv_want_endgame(loop, (uv_handle_t*) handle);
@@ -471,7 +471,7 @@ static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
 
 static int uv__slow_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
   assert(handle->type == UV_POLL);
-  assert(!(handle->flags & UV__HANDLE_CLOSING));
+  assert(!(handle->flags & UV_HANDLE_CLOSING));
   assert((events & ~(UV_READABLE | UV_WRITABLE)) == 0);
 
   handle->events = events;
@@ -633,7 +633,7 @@ int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle) {
 
 
 void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle) {
-  assert(handle->flags & UV__HANDLE_CLOSING);
+  assert(handle->flags & UV_HANDLE_CLOSING);
   assert(!(handle->flags & UV_HANDLE_CLOSED));
 
   assert(handle->submitted_events_1 == 0);
diff --git a/deps/uv/src/win/process-stdio.c b/deps/uv/src/win/process-stdio.c
index 0ae9f0624af88a..355d6188088b4a 100644
--- a/deps/uv/src/win/process-stdio.c
+++ b/deps/uv/src/win/process-stdio.c
@@ -103,6 +103,7 @@ static int uv__create_stdio_pipe_pair(uv_loop_t* loop,
   DWORD client_access = 0;
   HANDLE child_pipe = INVALID_HANDLE_VALUE;
   int err;
+  int overlap;
 
   if (flags & UV_READABLE_PIPE) {
     /* The server needs inbound access too, otherwise CreateNamedPipe() won't
@@ -130,7 +131,7 @@ static int uv__create_stdio_pipe_pair(uv_loop_t* loop,
   sa.lpSecurityDescriptor = NULL;
   sa.bInheritHandle = TRUE;
 
-  BOOL overlap = server_pipe->ipc || (flags & UV_OVERLAPPED_PIPE);
+  overlap = server_pipe->ipc || (flags & UV_OVERLAPPED_PIPE);
   child_pipe = CreateFileA(pipe_name,
                            client_access,
                            0,
diff --git a/deps/uv/src/win/process.c b/deps/uv/src/win/process.c
index 08910088e47ee1..b47f203e9d9c7f 100644
--- a/deps/uv/src/win/process.c
+++ b/deps/uv/src/win/process.c
@@ -872,7 +872,7 @@ void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
 
   /* If we're closing, don't call the exit callback. Just schedule a close
    * callback now. */
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     uv_want_endgame(loop, (uv_handle_t*) handle);
     return;
   }
@@ -924,7 +924,7 @@ void uv_process_close(uv_loop_t* loop, uv_process_t* handle) {
 
 void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) {
   assert(!handle->exit_cb_pending);
-  assert(handle->flags & UV__HANDLE_CLOSING);
+  assert(handle->flags & UV_HANDLE_CLOSING);
   assert(!(handle->flags & UV_HANDLE_CLOSED));
 
   /* Clean-up the process handle. */
diff --git a/deps/uv/src/win/signal.c b/deps/uv/src/win/signal.c
index 750c1b36ef88bc..3d0b8a35b93ace 100644
--- a/deps/uv/src/win/signal.c
+++ b/deps/uv/src/win/signal.c
@@ -90,7 +90,7 @@ int uv__signal_dispatch(int signum) {
     unsigned long previous = InterlockedExchange(
             (volatile LONG*) &handle->pending_signum, signum);
 
-    if (handle->flags & UV__SIGNAL_ONE_SHOT_DISPATCHED)
+    if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
       continue;
 
     if (!previous) {
@@ -98,8 +98,8 @@ int uv__signal_dispatch(int signum) {
     }
 
     dispatched = 1;
-    if (handle->flags & UV__SIGNAL_ONE_SHOT)
-      handle->flags |= UV__SIGNAL_ONE_SHOT_DISPATCHED;
+    if (handle->flags & UV_SIGNAL_ONE_SHOT)
+      handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
   }
 
   LeaveCriticalSection(&uv__signal_lock);
@@ -213,7 +213,7 @@ int uv__signal_start(uv_signal_t* handle,
 
   handle->signum = signum;
   if (oneshot)
-    handle->flags |= UV__SIGNAL_ONE_SHOT;
+    handle->flags |= UV_SIGNAL_ONE_SHOT;
 
   RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);
 
@@ -243,10 +243,10 @@ void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
   if (dispatched_signum == handle->signum)
     handle->signal_cb(handle, dispatched_signum);
 
-  if (handle->flags & UV__SIGNAL_ONE_SHOT)
+  if (handle->flags & UV_SIGNAL_ONE_SHOT)
     uv_signal_stop(handle);
 
-  if (handle->flags & UV__HANDLE_CLOSING) {
+  if (handle->flags & UV_HANDLE_CLOSING) {
     /* When it is closing, it must be stopped at this point. */
     assert(handle->signum == 0);
     uv_want_endgame(loop, (uv_handle_t*) handle);
@@ -265,7 +265,7 @@ void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle) {
 
 
 void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle) {
-  assert(handle->flags & UV__HANDLE_CLOSING);
+  assert(handle->flags & UV_HANDLE_CLOSING);
   assert(!(handle->flags & UV_HANDLE_CLOSED));
 
   assert(handle->signum == 0);
diff --git a/deps/uv/src/win/stream.c b/deps/uv/src/win/stream.c
index 3273a03c1cee4f..7656627e902da0 100644
--- a/deps/uv/src/win/stream.c
+++ b/deps/uv/src/win/stream.c
@@ -176,7 +176,7 @@ int uv_write2(uv_write_t* req,
 int uv_try_write(uv_stream_t* stream,
                  const uv_buf_t bufs[],
                  unsigned int nbufs) {
-  if (stream->flags & UV__HANDLE_CLOSING)
+  if (stream->flags & UV_HANDLE_CLOSING)
     return UV_EBADF;
   if (!(stream->flags & UV_HANDLE_WRITABLE))
     return UV_EPIPE;
diff --git a/deps/uv/src/win/tcp.c b/deps/uv/src/win/tcp.c
index 38cd73e0d12dc3..a97ab2a5188714 100644
--- a/deps/uv/src/win/tcp.c
+++ b/deps/uv/src/win/tcp.c
@@ -217,7 +217,7 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
     UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
 
     err = 0;
-    if (handle->flags & UV__HANDLE_CLOSING) {
+    if (handle->flags & UV_HANDLE_CLOSING) {
       err = ERROR_OPERATION_ABORTED;
     } else if (shutdown(handle->socket, SD_SEND) == SOCKET_ERROR) {
       err = WSAGetLastError();
@@ -233,7 +233,7 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
     return;
   }
 
-  if (handle->flags & UV__HANDLE_CLOSING &&
+  if (handle->flags & UV_HANDLE_CLOSING &&
       handle->reqs_pending == 0) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
 
@@ -680,7 +680,7 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
   req->next_pending = NULL;
   req->accept_socket = INVALID_SOCKET;
 
-  if (!(server->flags & UV__HANDLE_CLOSING)) {
+  if (!(server->flags & UV_HANDLE_CLOSING)) {
     /* Check if we're in a middle of changing the number of pending accepts. */
     if (!(server->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING)) {
       uv_tcp_queue_accept(server, req);
@@ -1166,7 +1166,7 @@ void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
 
   err = 0;
   if (REQ_SUCCESS(req)) {
-    if (handle->flags & UV__HANDLE_CLOSING) {
+    if (handle->flags & UV_HANDLE_CLOSING) {
       /* use UV_ECANCELED for consistency with Unix */
       err = ERROR_OPERATION_ABORTED;
     } else if (setsockopt(handle->socket,
diff --git a/deps/uv/src/win/thread.c b/deps/uv/src/win/thread.c
index 3342fd759435ef..6e41dcd8a087da 100644
--- a/deps/uv/src/win/thread.c
+++ b/deps/uv/src/win/thread.c
@@ -26,15 +26,6 @@
 #include "uv.h"
 #include "internal.h"
 
-static int uv_cond_condvar_init(uv_cond_t* cond);
-static void uv_cond_condvar_destroy(uv_cond_t* cond);
-static void uv_cond_condvar_signal(uv_cond_t* cond);
-static void uv_cond_condvar_broadcast(uv_cond_t* cond);
-static void uv_cond_condvar_wait(uv_cond_t* cond, uv_mutex_t* mutex);
-static int uv_cond_condvar_timedwait(uv_cond_t* cond,
-    uv_mutex_t* mutex, uint64_t timeout);
-
-
 static void uv__once_inner(uv_once_t* guard, void (*callback)(void)) {
   DWORD result;
   HANDLE existing_event, created_event;
@@ -374,7 +365,7 @@ int uv_cond_init(uv_cond_t* cond) {
 
 void uv_cond_destroy(uv_cond_t* cond) {
   /* nothing to do */
-  UV__UNUSED(cond);
+  (void) &cond;
 }
 
 
diff --git a/deps/uv/src/win/timer.c b/deps/uv/src/win/timer.c
deleted file mode 100644
index eda5c24f6e8392..00000000000000
--- a/deps/uv/src/win/timer.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include <assert.h>
-#include <limits.h>
-
-#include "uv.h"
-#include "internal.h"
-#include "uv/tree.h"
-#include "handle-inl.h"
-
-
-/* The number of milliseconds in one second. */
-#define UV__MILLISEC 1000
-
-
-void uv_update_time(uv_loop_t* loop) {
-  uint64_t new_time = uv__hrtime(UV__MILLISEC);
-  assert(new_time >= loop->time);
-  loop->time = new_time;
-}
-
-
-static int uv_timer_compare(uv_timer_t* a, uv_timer_t* b) {
-  if (a->due < b->due)
-    return -1;
-  if (a->due > b->due)
-    return 1;
-  /*
-   *  compare start_id when both has the same due. start_id is
-   *  allocated with loop->timer_counter in uv_timer_start().
-   */
-  if (a->start_id < b->start_id)
-    return -1;
-  if (a->start_id > b->start_id)
-    return 1;
-  return 0;
-}
-
-
-RB_GENERATE_STATIC(uv_timer_tree_s, uv_timer_s, tree_entry, uv_timer_compare)
-
-
-int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) {
-  uv__handle_init(loop, (uv_handle_t*) handle, UV_TIMER);
-  handle->timer_cb = NULL;
-  handle->repeat = 0;
-
-  return 0;
-}
-
-
-void uv_timer_endgame(uv_loop_t* loop, uv_timer_t* handle) {
-  if (handle->flags & UV__HANDLE_CLOSING) {
-    assert(!(handle->flags & UV_HANDLE_CLOSED));
-    uv__handle_close(handle);
-  }
-}
-
-
-static uint64_t get_clamped_due_time(uint64_t loop_time, uint64_t timeout) {
-  uint64_t clamped_timeout;
-
-  clamped_timeout = loop_time + timeout;
-  if (clamped_timeout < timeout)
-    clamped_timeout = (uint64_t) -1;
-
-  return clamped_timeout;
-}
-
-
-int uv_timer_start(uv_timer_t* handle, uv_timer_cb timer_cb, uint64_t timeout,
-    uint64_t repeat) {
-  uv_loop_t* loop = handle->loop;
-  uv_timer_t* old;
-
-  if (timer_cb == NULL)
-    return UV_EINVAL;
-
-  if (uv__is_active(handle))
-    uv_timer_stop(handle);
-
-  handle->timer_cb = timer_cb;
-  handle->due = get_clamped_due_time(loop->time, timeout);
-  handle->repeat = repeat;
-  uv__handle_start(handle);
-
-  /* start_id is the second index to be compared in uv__timer_cmp() */
-  handle->start_id = handle->loop->timer_counter++;
-
-  old = RB_INSERT(uv_timer_tree_s, &loop->timers, handle);
-  assert(old == NULL);
-
-  return 0;
-}
-
-
-int uv_timer_stop(uv_timer_t* handle) {
-  uv_loop_t* loop = handle->loop;
-
-  if (!uv__is_active(handle))
-    return 0;
-
-  RB_REMOVE(uv_timer_tree_s, &loop->timers, handle);
-  uv__handle_stop(handle);
-
-  return 0;
-}
-
-
-int uv_timer_again(uv_timer_t* handle) {
-  /* If timer_cb is NULL that means that the timer was never started. */
-  if (!handle->timer_cb) {
-    return UV_EINVAL;
-  }
-
-  if (handle->repeat) {
-    uv_timer_stop(handle);
-    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
-  }
-
-  return 0;
-}
-
-
-void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat) {
-  assert(handle->type == UV_TIMER);
-  handle->repeat = repeat;
-}
-
-
-uint64_t uv_timer_get_repeat(const uv_timer_t* handle) {
-  assert(handle->type == UV_TIMER);
-  return handle->repeat;
-}
-
-
-DWORD uv__next_timeout(const uv_loop_t* loop) {
-  uv_timer_t* timer;
-  int64_t delta;
-
-  /* Check if there are any running timers
-   * Need to cast away const first, since RB_MIN doesn't know what we are
-   * going to do with this return value, it can't be marked const
-   */
-  timer = RB_MIN(uv_timer_tree_s, &((uv_loop_t*)loop)->timers);
-  if (timer) {
-    delta = timer->due - loop->time;
-    if (delta >= UINT_MAX - 1) {
-      /* A timeout value of UINT_MAX means infinite, so that's no good. */
-      return UINT_MAX - 1;
-    } else if (delta < 0) {
-      /* Negative timeout values are not allowed */
-      return 0;
-    } else {
-      return (DWORD)delta;
-    }
-  } else {
-    /* No timers */
-    return INFINITE;
-  }
-}
-
-
-void uv_process_timers(uv_loop_t* loop) {
-  uv_timer_t* timer;
-
-  /* Call timer callbacks */
-  for (timer = RB_MIN(uv_timer_tree_s, &loop->timers);
-       timer != NULL && timer->due <= loop->time;
-       timer = RB_MIN(uv_timer_tree_s, &loop->timers)) {
-
-    uv_timer_stop(timer);
-    uv_timer_again(timer);
-    timer->timer_cb((uv_timer_t*) timer);
-  }
-}
diff --git a/deps/uv/src/win/tty.c b/deps/uv/src/win/tty.c
index ab4a648b2ec826..d62aafb7d8c921 100644
--- a/deps/uv/src/win/tty.c
+++ b/deps/uv/src/win/tty.c
@@ -2208,7 +2208,7 @@ void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
 
     /* TTY shutdown is really just a no-op */
     if (handle->stream.conn.shutdown_req->cb) {
-      if (handle->flags & UV__HANDLE_CLOSING) {
+      if (handle->flags & UV_HANDLE_CLOSING) {
         handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED);
       } else {
         handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0);
@@ -2221,7 +2221,7 @@ void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
     return;
   }
 
-  if (handle->flags & UV__HANDLE_CLOSING &&
+  if (handle->flags & UV_HANDLE_CLOSING &&
       handle->reqs_pending == 0) {
     /* The wait handle used for raw reading should be unregistered when the
      * wait callback runs. */
diff --git a/deps/uv/src/win/udp.c b/deps/uv/src/win/udp.c
index e56282ae44c74e..402aeea6666b5a 100644
--- a/deps/uv/src/win/udp.c
+++ b/deps/uv/src/win/udp.c
@@ -188,7 +188,7 @@ void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle) {
 
 
 void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
-  if (handle->flags & UV__HANDLE_CLOSING &&
+  if (handle->flags & UV_HANDLE_CLOSING &&
       handle->reqs_pending == 0) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     uv__handle_close(handle);
diff --git a/deps/uv/test/test-condvar.c b/deps/uv/test/test-condvar.c
index d956efef3c5a00..ec60f16403ad0b 100644
--- a/deps/uv/test/test-condvar.c
+++ b/deps/uv/test/test-condvar.c
@@ -25,221 +25,243 @@
 #include <string.h>
 #include <errno.h>
 
+struct worker_config;
+
+typedef void (*signal_func)(struct worker_config* c, int* flag);
+typedef int (*wait_func)(struct worker_config* c, const int* flag);
+
 typedef struct worker_config {
+  uv_sem_t sem_waiting; /* post before waiting. */
+  uv_sem_t sem_signaled; /* post after signaling. */
   uv_mutex_t mutex;
   uv_cond_t cond;
-  int signal_delay;
-  int wait_delay;
   int use_broadcast;
-  volatile int posted_1;
-  volatile int posted_2;
-  void (*signal_cond)(struct worker_config* c, volatile int* flag);
-  int (*wait_cond)(struct worker_config* c, const volatile int* flag);
+  int posted_1;
+  int posted_2;
+  signal_func signal_cond;
+  wait_func wait_cond;
 } worker_config;
 
+void worker_config_init(worker_config* wc,
+                        int use_broadcast,
+                        signal_func signal_f,
+                        wait_func wait_f) {
+  /* Wipe. */
+  memset(wc, 0, sizeof(*wc));
+
+  /* Copy vars. */
+  wc->signal_cond = signal_f;
+  wc->wait_cond = wait_f;
+  wc->use_broadcast = use_broadcast;
+
+  /* Init. */
+  ASSERT(0 == uv_sem_init(&wc->sem_waiting, 0));
+  ASSERT(0 == uv_sem_init(&wc->sem_signaled, 0));
+  ASSERT(0 == uv_cond_init(&wc->cond));
+  ASSERT(0 == uv_mutex_init(&wc->mutex));
+}
 
+void worker_config_destroy(worker_config* wc) {
+  uv_mutex_destroy(&wc->mutex);
+  uv_cond_destroy(&wc->cond);
+  uv_sem_destroy(&wc->sem_signaled);
+  uv_sem_destroy(&wc->sem_waiting);
+}
+
+/* arg is a worker_config.
+ * Call signal_cond then wait_cond.
+ * Partner should call wait then signal. */
 static void worker(void* arg) {
   worker_config* c = arg;
   c->signal_cond(c, &c->posted_1);
   c->wait_cond(c, &c->posted_2);
 }
 
-static void noop_worker(void* arg) {
-  return;
-}
-
-static void condvar_signal(worker_config* c, volatile int* flag) {
-  if (c->signal_delay)
-    uv_sleep(c->signal_delay);
+/* 1. Signal a waiting waiter.
+ * 2. Tell waiter we finished. */
+static void condvar_signal(worker_config* c, int* flag) {
+  /* Wait until waiter holds mutex and is preparing to wait. */
+  uv_sem_wait(&c->sem_waiting);
 
+  /* Make sure waiter has begun waiting. */
   uv_mutex_lock(&c->mutex);
+
+  /* Help waiter differentiate between spurious and legitimate wakeup. */
   ASSERT(*flag == 0);
   *flag = 1;
+
   if (c->use_broadcast)
     uv_cond_broadcast(&c->cond);
   else
     uv_cond_signal(&c->cond);
+
   uv_mutex_unlock(&c->mutex);
-}
 
+  /* Done signaling. */
+  uv_sem_post(&c->sem_signaled);
+}
 
-static int condvar_wait(worker_config* c, const volatile int* flag) {
+/* 1. Wait on a signal.
+ * 2. Ensure that the signaler finished. */
+static int condvar_wait(worker_config* c, const int* flag) {
   uv_mutex_lock(&c->mutex);
-  if (c->wait_delay)
-    uv_sleep(c->wait_delay);
-  while (*flag == 0) {
+
+  /* Tell signal'er that I am waiting. */
+  uv_sem_post(&c->sem_waiting);
+
+  /* Wait until I get a non-spurious signal. */
+  do {
     uv_cond_wait(&c->cond, &c->mutex);
-  }
+  } while (*flag == 0);
   ASSERT(*flag == 1);
+
   uv_mutex_unlock(&c->mutex);
 
+  /* Wait for my signal'er to finish. */
+  uv_sem_wait(&c->sem_signaled);
+
   return 0;
 }
 
-
+/* uv_cond_wait: One thread signals, the other waits. */
 TEST_IMPL(condvar_1) {
-  uv_thread_t thread;
   worker_config wc;
+  uv_thread_t thread;
 
-  memset(&wc, 0, sizeof(wc));
-  wc.wait_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_wait;
-
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
+  /* Helper signal-then-wait. */
+  worker_config_init(&wc, 0, condvar_signal, condvar_wait);
   ASSERT(0 == uv_thread_create(&thread, worker, &wc));
 
+  /* We wait-then-signal. */
   ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1));
   wc.signal_cond(&wc, &wc.posted_2);
 
   ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  worker_config_destroy(&wc);
 
   return 0;
 }
 
-
+/* uv_cond_wait: One thread broadcasts, the other waits. */
 TEST_IMPL(condvar_2) {
-  uv_thread_t thread;
   worker_config wc;
+  uv_thread_t thread;
 
-  memset(&wc, 0, sizeof(wc));
-  wc.signal_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_wait;
-
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
+  /* Helper to signal-then-wait. */
+  worker_config_init(&wc, 1, condvar_signal, condvar_wait);
   ASSERT(0 == uv_thread_create(&thread, worker, &wc));
 
+  /* We wait-then-signal. */
   ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1));
   wc.signal_cond(&wc, &wc.posted_2);
 
   ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  worker_config_destroy(&wc);
 
   return 0;
 }
 
-
-static int condvar_timedwait(worker_config* c, const volatile int* flag) {
+/* 1. Wait on a signal (hopefully not timeout, else we'll hang).
+ * 2. Ensure that the signaler finished. */
+static int condvar_timedwait(worker_config* c, const int* flag) {
   int r;
 
   r = 0;
 
   uv_mutex_lock(&c->mutex);
-  if (c->wait_delay)
-    uv_sleep(c->wait_delay);
-  while (*flag == 0) {
-    r = uv_cond_timedwait(&c->cond, &c->mutex, (uint64_t)(150 * 1e6));
-    ASSERT(r == 0 || r == UV_ETIMEDOUT);
-    if (r == UV_ETIMEDOUT)
-      break;
-  }
+
+  /* Tell signal'er that I am waiting. */
+  uv_sem_post(&c->sem_waiting);
+
+  /* Wait until I get a non-spurious signal. */
+  do {
+    r = uv_cond_timedwait(&c->cond, &c->mutex, (uint64_t)(1 * 1e9)); /* 1 s */
+    ASSERT(r == 0); /* Should not time out. */
+  } while (*flag == 0);
+  ASSERT(*flag == 1);
+
   uv_mutex_unlock(&c->mutex);
 
+  /* Wait for my signal'er to finish. */
+  uv_sem_wait(&c->sem_signaled);
   return r;
 }
 
-/* Test that uv_cond_timedwait will return early when cond is signaled. */
+/* uv_cond_timedwait: One thread signals, the other timedwaits. */
 TEST_IMPL(condvar_3) {
-  uv_thread_t thread;
   worker_config wc;
+  uv_thread_t thread;
 
-  memset(&wc, 0, sizeof(wc));
-  wc.signal_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_timedwait;
-
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
+  /* Helper to signal-then-wait. */
+  worker_config_init(&wc, 0, condvar_signal, condvar_timedwait);
   ASSERT(0 == uv_thread_create(&thread, worker, &wc));
 
-  ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1));
+  /* We wait-then-signal. */
+  wc.wait_cond(&wc, &wc.posted_1);
   wc.signal_cond(&wc, &wc.posted_2);
 
   ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  worker_config_destroy(&wc);
 
   return 0;
 }
 
-
+/* uv_cond_timedwait: One thread broadcasts, the other waits. */
 TEST_IMPL(condvar_4) {
-  uv_thread_t thread;
   worker_config wc;
+  uv_thread_t thread;
 
-  memset(&wc, 0, sizeof(wc));
-  wc.signal_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_timedwait;
-
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
+  /* Helper to signal-then-wait. */
+  worker_config_init(&wc, 1, condvar_signal, condvar_timedwait);
   ASSERT(0 == uv_thread_create(&thread, worker, &wc));
 
+  /* We wait-then-signal. */
   wc.wait_cond(&wc, &wc.posted_1);
   wc.signal_cond(&wc, &wc.posted_2);
 
   ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  worker_config_destroy(&wc);
 
   return 0;
 }
 
-
+/* uv_cond_timedwait: One thread waits, no signal. Timeout should be delivered. */
 TEST_IMPL(condvar_5) {
-  uv_thread_t thread;
   worker_config wc;
+  int r;
+  /* ns */
+  uint64_t before;
+  uint64_t after;
+  uint64_t elapsed;
+  uint64_t timeout;
 
-  memset(&wc, 0, sizeof(wc));
-  wc.use_broadcast = 1;
-  wc.signal_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_wait;
-
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
-  ASSERT(0 == uv_thread_create(&thread, worker, &wc));
-
-  wc.wait_cond(&wc, &wc.posted_1);
-  wc.signal_cond(&wc, &wc.posted_2);
+  timeout = 100 * 1e6; /* 100 ms in ns */
 
-  ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  /* Mostly irrelevant. We need cond and mutex initialized. */
+  worker_config_init(&wc, 0, NULL, NULL);
 
-  return 0;
-}
+  uv_mutex_lock(&wc.mutex);
 
-/* Test that uv_cond_timedwait will time out when cond is not signaled. */
-TEST_IMPL(condvar_6) {
-  uv_thread_t thread;
-  worker_config wc;
-  int r;
+  /* We wait.
+   * No signaler, so this will only return if timeout is delivered. */
+  before = uv_hrtime();
+  r = uv_cond_timedwait(&wc.cond, &wc.mutex, timeout);
+  after = uv_hrtime();
 
-  memset(&wc, 0, sizeof(wc));
-  wc.signal_delay = 100;
-  wc.signal_cond = condvar_signal;
-  wc.wait_cond = condvar_timedwait;
+  uv_mutex_unlock(&wc.mutex);
 
-  ASSERT(0 == uv_cond_init(&wc.cond));
-  ASSERT(0 == uv_mutex_init(&wc.mutex));
-  ASSERT(0 == uv_thread_create(&thread, noop_worker, &wc));
-
-  /* This can only return having timed out, because otherwise we
-   * loop forever in condvar_timedwait. */
-  r = wc.wait_cond(&wc, &wc.posted_1);
+  /* It timed out. */
   ASSERT(r == UV_ETIMEDOUT);
 
-  ASSERT(0 == uv_thread_join(&thread));
-  uv_mutex_destroy(&wc.mutex);
-  uv_cond_destroy(&wc.cond);
+  /* It must have taken at least timeout, modulo system timer ticks.
+   * But it should not take too much longer.
+   * cf. MSDN docs:
+   * https://msdn.microsoft.com/en-us/library/ms687069(VS.85).aspx */
+  elapsed = after - before;
+  ASSERT(0.75 * timeout <= elapsed); /* 1.0 too large for Windows. */
+  ASSERT(elapsed <= 1.5 * timeout); /* 1.1 too small for OSX. */
+
+  worker_config_destroy(&wc);
 
   return 0;
 }
diff --git a/deps/uv/test/test-error.c b/deps/uv/test/test-error.c
index a2d559a4ee1564..7f44f4a1bc606d 100644
--- a/deps/uv/test/test-error.c
+++ b/deps/uv/test/test-error.c
@@ -37,6 +37,8 @@
  * See https://github.com/joyent/libuv/issues/210
  */
 TEST_IMPL(error_message) {
+  char buf[32];
+
   /* Cop out. Can't do proper checks on systems with
    * i18n-ized error messages...
    */
@@ -49,6 +51,10 @@ TEST_IMPL(error_message) {
   ASSERT(strcmp(uv_strerror(1337), "Unknown error") == 0);
   ASSERT(strcmp(uv_strerror(-1337), "Unknown error") == 0);
 
+  ASSERT(strstr(uv_strerror_r(UV_EINVAL, buf, sizeof(buf)), "Success") == NULL);
+  ASSERT(strstr(uv_strerror_r(1337, buf, sizeof(buf)), "1337") != NULL);
+  ASSERT(strstr(uv_strerror_r(-1337, buf, sizeof(buf)), "-1337") != NULL);
+
   return 0;
 }
 
diff --git a/deps/uv/test/test-list.h b/deps/uv/test/test-list.h
index e59c6b65513787..24ba37461eb4de 100644
--- a/deps/uv/test/test-list.h
+++ b/deps/uv/test/test-list.h
@@ -42,7 +42,6 @@ TEST_DECLARE   (condvar_2)
 TEST_DECLARE   (condvar_3)
 TEST_DECLARE   (condvar_4)
 TEST_DECLARE   (condvar_5)
-TEST_DECLARE   (condvar_6)
 TEST_DECLARE   (semaphore_1)
 TEST_DECLARE   (semaphore_2)
 TEST_DECLARE   (semaphore_3)
@@ -459,7 +458,6 @@ TASK_LIST_START
   TEST_ENTRY  (condvar_3)
   TEST_ENTRY  (condvar_4)
   TEST_ENTRY  (condvar_5)
-  TEST_ENTRY  (condvar_6)
   TEST_ENTRY  (semaphore_1)
   TEST_ENTRY  (semaphore_2)
   TEST_ENTRY  (semaphore_3)
diff --git a/deps/uv/test/test-tty.c b/deps/uv/test/test-tty.c
index e761822fa349fc..6aaeda8f59619b 100644
--- a/deps/uv/test/test-tty.c
+++ b/deps/uv/test/test-tty.c
@@ -371,12 +371,12 @@ TEST_IMPL(tty_pty) {
   ASSERT(0 == uv_tty_init(&loop, &slave_tty, slave_fd, 0));
   ASSERT(0 == uv_tty_init(&loop, &master_tty, master_fd, 0));
   /* Check if the file descriptor was reopened. If it is,
-   * UV_STREAM_BLOCKING (value 0x80) isn't set on flags.
+   * UV_HANDLE_BLOCKING_WRITES (value 0x100000) isn't set on flags.
    */
-  ASSERT(0 == (slave_tty.flags & 0x80));
+  ASSERT(0 == (slave_tty.flags & 0x100000));
   /* The master_fd of a pty should never be reopened.
    */
-  ASSERT(master_tty.flags & 0x80);
+  ASSERT(master_tty.flags & 0x100000);
   ASSERT(0 == close(slave_fd));
   uv_close((uv_handle_t*) &slave_tty, NULL);
   ASSERT(0 == close(master_fd));
diff --git a/deps/uv/uv.gyp b/deps/uv/uv.gyp
index 8aaf541b996f51..37dcb3604f4c72 100644
--- a/deps/uv/uv.gyp
+++ b/deps/uv/uv.gyp
@@ -73,6 +73,7 @@
         'src/inet.c',
         'src/queue.h',
         'src/threadpool.c',
+        'src/timer.c',
         'src/uv-data-getter-setters.c',
         'src/uv-common.c',
         'src/uv-common.h',
@@ -123,7 +124,6 @@
             'src/win/stream-inl.h',
             'src/win/tcp.c',
             'src/win/tty.c',
-            'src/win/timer.c',
             'src/win/udp.c',
             'src/win/util.c',
             'src/win/winapi.c',
@@ -168,7 +168,6 @@
             'src/unix/stream.c',
             'src/unix/tcp.c',
             'src/unix/thread.c',
-            'src/unix/timer.c',
             'src/unix/tty.c',
             'src/unix/udp.c',
           ],

From 277077853fa062f8a101b9af86e62b23168c87ae Mon Sep 17 00:00:00 2001
From: Jon Moss <me@jonathanmoss.me>
Date: Mon, 9 Jul 2018 11:02:11 -0400
Subject: [PATCH 047/116] src: make Environment::is_stopping_worker inline

Fixes a TODO comment.

PR-URL: https://github.com/nodejs/node/pull/21720
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/env-inl.h | 6 ++++++
 src/env.cc    | 5 -----
 src/env.h     | 4 +---
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/env-inl.h b/src/env-inl.h
index bbb80c6f7ae916..8b878431ac65a3 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -33,6 +33,7 @@
 #include "node_perf_common.h"
 #include "node_context_data.h"
 #include "tracing/agent.h"
+#include "node_worker.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ -623,6 +624,11 @@ inline void Environment::remove_sub_worker_context(worker::Worker* context) {
   sub_worker_contexts_.erase(context);
 }
 
+inline bool Environment::is_stopping_worker() const {
+  CHECK(!is_main_thread());
+  return worker_context_->is_stopped();
+}
+
 inline performance::performance_state* Environment::performance_state() {
   return performance_state_.get();
 }
diff --git a/src/env.cc b/src/env.cc
index 2236893dd77923..6c906e2fb19c56 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -653,9 +653,4 @@ void Environment::stop_sub_worker_contexts() {
   }
 }
 
-bool Environment::is_stopping_worker() const {
-  CHECK(!is_main_thread());
-  return worker_context_->is_stopped();
-}
-
 }  // namespace node
diff --git a/src/env.h b/src/env.h
index c7e75004bf0ceb..38be74542b2599 100644
--- a/src/env.h
+++ b/src/env.h
@@ -723,9 +723,6 @@ class Environment {
   inline bool can_call_into_js() const;
   inline void set_can_call_into_js(bool can_call_into_js);
 
-  // TODO(addaleax): This should be inline.
-  bool is_stopping_worker() const;
-
   inline bool is_main_thread() const;
   inline uint64_t thread_id() const;
   inline void set_thread_id(uint64_t id);
@@ -734,6 +731,7 @@ class Environment {
   inline void add_sub_worker_context(worker::Worker* context);
   inline void remove_sub_worker_context(worker::Worker* context);
   void stop_sub_worker_contexts();
+  inline bool is_stopping_worker() const;
 
   inline void ThrowError(const char* errmsg);
   inline void ThrowTypeError(const char* errmsg);

From 4f3bbfaaca9817fce8d2282207719e4745ab4c63 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 9 Jul 2018 11:41:58 -0400
Subject: [PATCH 048/116] n-api: test uint32 truncation

Re: https://github.com/nodejs/abi-stable-node/issues/55#issuecomment-403382424
PR-URL: https://github.com/nodejs/node/pull/21722
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_number/test.js       | 14 +++++++++++++
 test/addons-napi/test_number/test_number.c | 23 ++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
index 6c04a222cb4eb6..34f48aee578ac6 100644
--- a/test/addons-napi/test_number/test.js
+++ b/test/addons-napi/test_number/test.js
@@ -35,6 +35,20 @@ testNumber(Number.POSITIVE_INFINITY);
 testNumber(Number.NEGATIVE_INFINITY);
 testNumber(Number.NaN);
 
+function testUint32(input, expected = input) {
+  assert.strictEqual(expected, test_number.TestUint32Truncation(input));
+}
+
+// Test zero
+testUint32(0.0, 0);
+testUint32(-0.0, 0);
+
+// Test overflow scenarios
+testUint32(4294967295);
+testUint32(4294967296, 0);
+testUint32(4294967297, 1);
+testUint32(17 * 4294967296 + 1, 1);
+
 // validate documented behavior when value is retrieved as 32-bit integer with
 // `napi_get_value_int32`
 function testInt32(input, expected = input) {
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index 19b0ae83f051df..63290bf6d64d7e 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -23,6 +23,28 @@ static napi_value Test(napi_env env, napi_callback_info info) {
   return output;
 }
 
+static napi_value TestUint32Truncation(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_number,
+      "Wrong type of arguments. Expects a number as first argument.");
+
+  uint32_t input;
+  NAPI_CALL(env, napi_get_value_uint32(env, args[0], &input));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_uint32(env, input, &output));
+
+  return output;
+}
+
 static napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -71,6 +93,7 @@ static napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestInt32Truncation", TestInt32Truncation),
+    DECLARE_NAPI_PROPERTY("TestUint32Truncation", TestUint32Truncation),
     DECLARE_NAPI_PROPERTY("TestInt64Truncation", TestInt64Truncation),
   };
 

From b9bbbbe5d190f716e1e3467cec5fb6c8bbb2bf23 Mon Sep 17 00:00:00 2001
From: Sam Ruby <rubys@intertwingly.net>
Date: Tue, 3 Jul 2018 12:46:56 -0400
Subject: [PATCH 049/116] tools: build all.json by combining generated JSON

Notes:

1) Removed a number of root properties that did not seem relevant:
   source, desc, and introduced_in.  There no longer is a source, and
   the other two are from the first include and do not reflect the
   entire API.

2) As with https://github.com/nodejs/node/issues/20100, the current
   "desc" properties sometimes contained in-page links, other times
   referenced another page, and often did not match the links in the
   original HTML or JSON file. I chose to standardize on external links
   as "desc" values are isolated snippets as opposed to all.html which
   can be viewed as a standalone and self contained document.

3) Eliminated preprocessing for @include entirely, including the test
   case for this function.

4) _toc.md was renamed to index.md.

5) index comments no longer appear in embedded TOCs (left hand side
   column in the generated documentation.

PR-URL: https://github.com/nodejs/node/pull/21637
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 Makefile                           |  8 ++--
 doc/api/_toc.md                    | 62 ----------------------------
 doc/api/all.md                     | 50 -----------------------
 doc/api/index.md                   | 65 +++++++++++++++++++++++++++++-
 test/doctool/test-doctool-html.js  | 64 ++++++++++++-----------------
 test/doctool/test-make-doc.js      | 10 ++---
 test/fixtures/doc_with_includes.md |  2 -
 tools/doc/allhtml.js               | 13 +++---
 tools/doc/alljson.js               | 56 +++++++++++++++++++++++++
 tools/doc/generate.js              |  9 +----
 tools/doc/html.js                  |  4 +-
 tools/doc/preprocess.js            | 38 -----------------
 12 files changed, 165 insertions(+), 216 deletions(-)
 delete mode 100644 doc/api/_toc.md
 delete mode 100644 doc/api/all.md
 delete mode 100644 test/fixtures/doc_with_includes.md
 create mode 100644 tools/doc/alljson.js
 delete mode 100644 tools/doc/preprocess.js

diff --git a/Makefile b/Makefile
index 6bba4c5052574e..03285c9d42cee3 100644
--- a/Makefile
+++ b/Makefile
@@ -622,7 +622,7 @@ doc-only: $(apidoc_dirs) $(apiassets)  ## Builds the docs with the local or the
 	if [ ! -d doc/api/assets ]; then \
 		$(MAKE) tools/doc/node_modules/js-yaml/package.json; \
 	fi;
-	@$(MAKE) $(apidocs_html) $(apidocs_json)
+	@$(MAKE) out/doc/api/all.html out/doc/api/all.json
 
 .PHONY: doc
 doc: $(NODE_EXE) doc-only
@@ -672,10 +672,12 @@ out/doc/api/%.json: doc/api/%.md tools/doc/generate.js tools/doc/json.js
 out/doc/api/%.html: doc/api/%.md tools/doc/generate.js tools/doc/html.js
 	$(call available-node, $(gen-html))
 
-out/doc/api/all.html: $(filter-out out/doc/api/all.html, $(apidocs_html)) \
-	tools/doc/allhtml.js
+out/doc/api/all.html: $(apidocs_html) tools/doc/allhtml.js
 	$(call available-node, tools/doc/allhtml.js)
 
+out/doc/api/all.json: $(apidocs_json) tools/doc/alljson.js
+	$(call available-node, tools/doc/alljson.js)
+
 .PHONY: docopen
 docopen: $(apidocs_html)
 	@$(PYTHON) -mwebbrowser file://$(PWD)/out/doc/api/all.html
diff --git a/doc/api/_toc.md b/doc/api/_toc.md
deleted file mode 100644
index e307d52ae8544e..00000000000000
--- a/doc/api/_toc.md
+++ /dev/null
@@ -1,62 +0,0 @@
-@// NB(chrisdickinson): if you move this file, be sure to update
-@// tools/doc/html.js to point at the new location.
-
-<!--introduced_in=v0.10.0-->
-
-* [About these Docs](documentation.html)
-* [Usage & Example](synopsis.html)
-
-<div class="line"></div>
-
-* [Assertion Testing](assert.html)
-* [Async Hooks](async_hooks.html)
-* [Buffer](buffer.html)
-* [C++ Addons](addons.html)
-* [C/C++ Addons - N-API](n-api.html)
-* [Child Processes](child_process.html)
-* [Cluster](cluster.html)
-* [Command Line Options](cli.html)
-* [Console](console.html)
-* [Crypto](crypto.html)
-* [Debugger](debugger.html)
-* [Deprecated APIs](deprecations.html)
-* [DNS](dns.html)
-* [Domain](domain.html)
-* [ECMAScript Modules](esm.html)
-* [Errors](errors.html)
-* [Events](events.html)
-* [File System](fs.html)
-* [Globals](globals.html)
-* [HTTP](http.html)
-* [HTTP/2](http2.html)
-* [HTTPS](https.html)
-* [Inspector](inspector.html)
-* [Internationalization](intl.html)
-* [Modules](modules.html)
-* [Net](net.html)
-* [OS](os.html)
-* [Path](path.html)
-* [Performance Hooks](perf_hooks.html)
-* [Process](process.html)
-* [Punycode](punycode.html)
-* [Query Strings](querystring.html)
-* [Readline](readline.html)
-* [REPL](repl.html)
-* [Stream](stream.html)
-* [String Decoder](string_decoder.html)
-* [Timers](timers.html)
-* [TLS/SSL](tls.html)
-* [Trace Events](tracing.html)
-* [TTY](tty.html)
-* [UDP/Datagram](dgram.html)
-* [URL](url.html)
-* [Utilities](util.html)
-* [V8](v8.html)
-* [VM](vm.html)
-* [Worker Threads](worker_threads.html)
-* [ZLIB](zlib.html)
-
-<div class="line"></div>
-
-* [GitHub Repo & Issue Tracker](https://github.com/nodejs/node)
-* [Mailing List](https://groups.google.com/group/nodejs)
diff --git a/doc/api/all.md b/doc/api/all.md
deleted file mode 100644
index 47216b695d3351..00000000000000
--- a/doc/api/all.md
+++ /dev/null
@@ -1,50 +0,0 @@
-<!--lint disable prohibited-strings-->
-@include documentation
-@include synopsis
-@include assert
-@include async_hooks
-@include buffer
-@include addons
-@include n-api
-@include child_process
-@include cluster
-@include cli
-@include console
-@include crypto
-@include debugger
-@include deprecations
-@include dns
-@include domain
-@include esm
-@include errors
-@include events
-@include fs
-@include globals
-@include http
-@include http2
-@include https
-@include inspector
-@include intl
-@include modules
-@include net
-@include os
-@include path
-@include perf_hooks
-@include process
-@include punycode
-@include querystring
-@include readline
-@include repl
-@include stream
-@include string_decoder
-@include timers
-@include tls
-@include tracing
-@include tty
-@include dgram
-@include url
-@include util
-@include v8
-@include vm
-@include worker_threads
-@include zlib
diff --git a/doc/api/index.md b/doc/api/index.md
index 400faf6e5ed34a..0b43097bf294de 100644
--- a/doc/api/index.md
+++ b/doc/api/index.md
@@ -1 +1,64 @@
-@include _toc.md
+<!--
+  NB(chrisdickinson): if you move this file, be sure to update
+  tools/doc/html.js to point at the new location.
+-->
+
+<!--introduced_in=v0.10.0-->
+
+* [About these Docs](documentation.html)
+* [Usage & Example](synopsis.html)
+
+<div class="line"></div>
+
+* [Assertion Testing](assert.html)
+* [Async Hooks](async_hooks.html)
+* [Buffer](buffer.html)
+* [C++ Addons](addons.html)
+* [C/C++ Addons - N-API](n-api.html)
+* [Child Processes](child_process.html)
+* [Cluster](cluster.html)
+* [Command Line Options](cli.html)
+* [Console](console.html)
+* [Crypto](crypto.html)
+* [Debugger](debugger.html)
+* [Deprecated APIs](deprecations.html)
+* [DNS](dns.html)
+* [Domain](domain.html)
+* [ECMAScript Modules](esm.html)
+* [Errors](errors.html)
+* [Events](events.html)
+* [File System](fs.html)
+* [Globals](globals.html)
+* [HTTP](http.html)
+* [HTTP/2](http2.html)
+* [HTTPS](https.html)
+* [Inspector](inspector.html)
+* [Internationalization](intl.html)
+* [Modules](modules.html)
+* [Net](net.html)
+* [OS](os.html)
+* [Path](path.html)
+* [Performance Hooks](perf_hooks.html)
+* [Process](process.html)
+* [Punycode](punycode.html)
+* [Query Strings](querystring.html)
+* [Readline](readline.html)
+* [REPL](repl.html)
+* [Stream](stream.html)
+* [String Decoder](string_decoder.html)
+* [Timers](timers.html)
+* [TLS/SSL](tls.html)
+* [Trace Events](tracing.html)
+* [TTY](tty.html)
+* [UDP/Datagram](dgram.html)
+* [URL](url.html)
+* [Utilities](util.html)
+* [V8](v8.html)
+* [VM](vm.html)
+* [Worker Threads](worker_threads.html)
+* [ZLIB](zlib.html)
+
+<div class="line"></div>
+
+* [GitHub Repo & Issue Tracker](https://github.com/nodejs/node)
+* [Mailing List](https://groups.google.com/group/nodejs)
diff --git a/test/doctool/test-doctool-html.js b/test/doctool/test-doctool-html.js
index 0ca46c0adedfc1..a6119c16903a74 100644
--- a/test/doctool/test-doctool-html.js
+++ b/test/doctool/test-doctool-html.js
@@ -11,7 +11,6 @@ try {
 const assert = require('assert');
 const { readFile } = require('fs');
 const fixtures = require('../common/fixtures');
-const processIncludes = require('../../tools/doc/preprocess.js');
 const toHTML = require('../../tools/doc/html.js');
 
 // Test data is a list of objects with two properties.
@@ -64,15 +63,6 @@ const testData = [
       '<!-- This is not a metadata comment --> ' +
       '<p>Describe <code>Something</code> in more detail here. </p>'
   },
-  {
-    file: fixtures.path('doc_with_includes.md'),
-    html: '<!-- [start-include:doc_inc_1.md] -->' +
-    '<p>Look <a href="doc_inc_2.html#doc_inc_2_foobar">here</a>!</p>' +
-    '<!-- [end-include:doc_inc_1.md] --><!-- [start-include:doc_inc_2.md] -->' +
-    '<h1>foobar<span><a class="mark" href="#doc_inc_2_foobar" ' +
-    'id="doc_inc_2_foobar">#</a></span></h1>' +
-    '<p>I exist and am being linked to.</p><!-- [end-include:doc_inc_2.md] -->'
-  },
   {
     file: fixtures.path('sample_document.md'),
     html: '<ol><li>fish</li><li><p>fish</p></li><li><p>Redfish</p></li>' +
@@ -90,36 +80,34 @@ testData.forEach(({ file, html, analyticsId }) => {
 
   readFile(file, 'utf8', common.mustCall((err, input) => {
     assert.ifError(err);
-    processIncludes(file, input, common.mustCall((err, preprocessed) => {
-      assert.ifError(err);
 
-      toHTML(
-        {
-          input: preprocessed,
-          filename: 'foo',
-          nodeVersion: process.version,
-          analytics: analyticsId,
-        },
-        common.mustCall((err, output) => {
-          assert.ifError(err);
+    toHTML(
+      {
+        input: input,
+        filename: 'foo',
+        nodeVersion: process.version,
+        analytics: analyticsId,
+      },
+      common.mustCall((err, output) => {
+        assert.ifError(err);
 
-          const actual = output.replace(spaces, '');
-          // Assert that the input stripped of all whitespace contains the
-          // expected markup.
-          assert(actual.includes(expected));
+        const actual = output.replace(spaces, '');
+        // Assert that the input stripped of all whitespace contains the
+        // expected markup.
+        assert(actual.includes(expected));
 
-          // Testing the insertion of Google Analytics script when
-          // an analytics id is provided. Should not be present by default.
-          const scriptDomain = 'google-analytics.com';
-          if (includeAnalytics) {
-            assert(actual.includes(scriptDomain),
-                   `Google Analytics script was not present in "${actual}"`);
-          } else {
-            assert.strictEqual(actual.includes(scriptDomain), false,
-                               'Google Analytics script was present in ' +
-                               `"${actual}"`);
-          }
-        }));
-    }));
+        // Testing the insertion of Google Analytics script when
+        // an analytics id is provided. Should not be present by default.
+        const scriptDomain = 'google-analytics.com';
+        if (includeAnalytics) {
+          assert(actual.includes(scriptDomain),
+                 `Google Analytics script was not present in "${actual}"`);
+        } else {
+          assert.strictEqual(actual.includes(scriptDomain), false,
+                             'Google Analytics script was present in ' +
+                             `"${actual}"`);
+        }
+      })
+    );
   }));
 });
diff --git a/test/doctool/test-make-doc.js b/test/doctool/test-make-doc.js
index e019288f75cc1e..a11da0e97d8355 100644
--- a/test/doctool/test-make-doc.js
+++ b/test/doctool/test-make-doc.js
@@ -13,17 +13,16 @@ const path = require('path');
 
 const apiPath = path.resolve(__dirname, '..', '..', 'out', 'doc', 'api');
 const allDocs = fs.readdirSync(apiPath);
-assert.ok(allDocs.includes('_toc.html'));
+assert.ok(allDocs.includes('index.html'));
 
 const actualDocs = allDocs.filter(
   (name) => {
     const extension = path.extname(name);
-    return (extension === '.html' || extension === '.json') &&
-           name !== '_toc.html';
+    return extension === '.html' || extension === '.json';
   }
 );
 
-const toc = fs.readFileSync(path.resolve(apiPath, '_toc.html'), 'utf8');
+const toc = fs.readFileSync(path.resolve(apiPath, 'index.html'), 'utf8');
 const re = /href="([^/]+\.html)"/;
 const globalRe = new RegExp(re, 'g');
 const links = toc.match(globalRe);
@@ -32,8 +31,7 @@ assert.notStrictEqual(links, null);
 // Filter out duplicate links, leave just filenames, add expected JSON files.
 const linkedHtmls = [...new Set(links)].map((link) => link.match(re)[1]);
 const expectedJsons = linkedHtmls
-                       .map((name) => name.replace('.html', '.json'))
-                       .concat('_toc.json');
+                       .map((name) => name.replace('.html', '.json'));
 const expectedDocs = linkedHtmls.concat(expectedJsons);
 
 // Test that all the relative links in the TOC match to the actual documents.
diff --git a/test/fixtures/doc_with_includes.md b/test/fixtures/doc_with_includes.md
deleted file mode 100644
index 901bf0f1b0bf3b..00000000000000
--- a/test/fixtures/doc_with_includes.md
+++ /dev/null
@@ -1,2 +0,0 @@
-@include doc_inc_1
-@include doc_inc_2.md
diff --git a/tools/doc/allhtml.js b/tools/doc/allhtml.js
index fad530f1c44245..1c84e13d0ab79c 100644
--- a/tools/doc/allhtml.js
+++ b/tools/doc/allhtml.js
@@ -12,7 +12,7 @@ const htmlFiles = fs.readdirSync(source, 'utf8')
   .filter((name) => name.includes('.html') && name !== 'all.html');
 
 // Read the table of contents.
-const toc = fs.readFileSync(source + '/_toc.html', 'utf8');
+const toc = fs.readFileSync(source + '/index.html', 'utf8');
 
 // Extract (and concatenate) the toc and apicontent from each document.
 let contents = '';
@@ -47,11 +47,12 @@ for (const link of toc.match(/<a.*?>/g)) {
   seen[href] = true;
 }
 
-// Replace various mentions of _toc with all.
-let all = toc.replace(/_toc\.html/g, 'all.html')
-  .replace('_toc.json', 'all.json')
-  .replace('api-section-_toc', 'api-section-all')
-  .replace('data-id="_toc"', 'data-id="all"');
+// Replace various mentions of index with all.
+let all = toc.replace(/index\.html/g, 'all.html')
+  .replace('<a href="all.html" name="toc">', '<a href="index.html" name="toc">')
+  .replace('index.json', 'all.json')
+  .replace('api-section-index', 'api-section-all')
+  .replace('data-id="index"', 'data-id="all"');
 
 // Clean up the title.
 all = all.replace(/<title>.*?\| /, '<title>');
diff --git a/tools/doc/alljson.js b/tools/doc/alljson.js
new file mode 100644
index 00000000000000..7e027f764e7efd
--- /dev/null
+++ b/tools/doc/alljson.js
@@ -0,0 +1,56 @@
+'use strict';
+
+// Build all.json by combining the miscs, modules, classes, globals, and methods
+// from the generated json files.
+
+const fs = require('fs');
+
+const source = `${__dirname}/../../out/doc/api`;
+
+// Get a list of generated API documents.
+const jsonFiles = fs.readdirSync(source, 'utf8')
+  .filter((name) => name.includes('.json') && name !== 'all.json');
+
+// Read the table of contents.
+const toc = fs.readFileSync(source + '/index.html', 'utf8');
+
+// Initialize results. Only these four data values will be collected.
+const results = {
+  miscs: [],
+  modules: [],
+  classes: [],
+  globals: [],
+  methods: []
+};
+
+// Identify files that should be skipped. As files are processed, they
+// are added to this list to prevent dupes.
+const seen = {
+  'all.json': true,
+  'index.json': true
+};
+
+// Extract (and concatenate) the selected data from each document.
+// Expand hrefs found in json to include source HTML file.
+for (const link of toc.match(/<a.*?>/g)) {
+  const href = /href="(.*?)"/.exec(link)[1];
+  const json = href.replace('.html', '.json');
+  if (!jsonFiles.includes(json) || seen[json]) continue;
+  const data = JSON.parse(
+    fs.readFileSync(source + '/' + json, 'utf8')
+      .replace(/<a href=\\"#/g, `<a href=\\"${href}#`)
+  );
+
+  for (const property in data) {
+    if (results.hasOwnProperty(property)) {
+      results[property].push(...data[property]);
+    }
+  }
+
+  // Mark source as seen.
+  seen[json] = true;
+}
+
+// Write results.
+fs.writeFileSync(source + '/all.json',
+                 `${JSON.stringify(results, null, 2)}\n`, 'utf8');
diff --git a/tools/doc/generate.js b/tools/doc/generate.js
index 9f217b19c7225f..8ed97610cf3bc2 100644
--- a/tools/doc/generate.js
+++ b/tools/doc/generate.js
@@ -21,7 +21,6 @@
 
 'use strict';
 
-const processIncludes = require('./preprocess.js');
 const fs = require('fs');
 
 // Parse the args.
@@ -52,12 +51,6 @@ if (!filename) {
 }
 
 fs.readFile(filename, 'utf8', (er, input) => {
-  if (er) throw er;
-  // Process the input for @include lines.
-  processIncludes(filename, input, next);
-});
-
-function next(er, input) {
   if (er) throw er;
   switch (format) {
     case 'json':
@@ -78,4 +71,4 @@ function next(er, input) {
     default:
       throw new Error(`Invalid format: ${format}`);
   }
-}
+});
diff --git a/tools/doc/html.js b/tools/doc/html.js
index 871a55baf4676c..0e254f1203f7a6 100644
--- a/tools/doc/html.js
+++ b/tools/doc/html.js
@@ -36,8 +36,8 @@ marked.setOptions({ renderer });
 
 const docPath = path.resolve(__dirname, '..', '..', 'doc');
 
-const gtocPath = path.join(docPath, 'api', '_toc.md');
-const gtocMD = fs.readFileSync(gtocPath, 'utf8').replace(/^@\/\/.*$/gm, '');
+const gtocPath = path.join(docPath, 'api', 'index.md');
+const gtocMD = fs.readFileSync(gtocPath, 'utf8').replace(/^<!--.*?-->/gms, '');
 const gtocHTML = marked(gtocMD).replace(
   /<a href="(.*?)"/g,
   (all, href) => `<a class="nav-${href.replace('.html', '')
diff --git a/tools/doc/preprocess.js b/tools/doc/preprocess.js
deleted file mode 100644
index 554af2ccb77ae0..00000000000000
--- a/tools/doc/preprocess.js
+++ /dev/null
@@ -1,38 +0,0 @@
-'use strict';
-
-module.exports = processIncludes;
-
-const path = require('path');
-const fs = require('fs');
-
-const includeExpr = /^@include\s+([\w-]+)(?:\.md)?$/gmi;
-const commentExpr = /^@\/\/.*$/gm;
-
-function processIncludes(inputFile, input, cb) {
-  const includes = input.match(includeExpr);
-  if (includes === null)
-    return cb(null, input.replace(commentExpr, ''));
-
-  let errState = null;
-  let incCount = includes.length;
-
-  includes.forEach((include) => {
-    const fname = include.replace(includeExpr, '$1.md');
-    const fullFname = path.resolve(path.dirname(inputFile), fname);
-
-    fs.readFile(fullFname, 'utf8', function(er, inc) {
-      if (errState) return;
-      if (er) return cb(errState = er);
-      incCount--;
-
-      // Add comments to let the HTML generator know
-      // how the anchors for headings should look like.
-      inc = `<!-- [start-include:${fname}] -->\n` +
-            `${inc}\n<!-- [end-include:${fname}] -->\n`;
-      input = input.split(`${include}\n`).join(`${inc}\n`);
-
-      if (incCount === 0)
-        return cb(null, input.replace(commentExpr, ''));
-    });
-  });
-}

From 48b16aad47d321885ae02ada6afe4ef2532c09b7 Mon Sep 17 00:00:00 2001
From: Jon Moss <me@jonathanmoss.me>
Date: Sat, 7 Jul 2018 17:24:27 -0400
Subject: [PATCH 050/116] zlib: instance-ify two methods

Both `Params` and `SetDictionary` take `ZCtx` as an arg, so just make
them both instance methods on `ZCtx`.

PR-URL: https://github.com/nodejs/node/pull/21702
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_zlib.cc | 40 ++++++++++++++++++----------------------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 893209d4d42012..169816d16f48b6 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -486,7 +486,7 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
                     write_js_callback, dictionary, dictionary_len);
     if (!ret) goto end;
 
-    SetDictionary(ctx);
+    ctx->SetDictionary();
 
    end:
     return args.GetReturnValue().Set(ret);
@@ -496,14 +496,14 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
     CHECK(args.Length() == 2 && "params(level, strategy)");
     ZCtx* ctx;
     ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
-    Params(ctx, args[0]->Int32Value(), args[1]->Int32Value());
+    ctx->Params(args[0]->Int32Value(), args[1]->Int32Value());
   }
 
   static void Reset(const FunctionCallbackInfo<Value> &args) {
     ZCtx* ctx;
     ASSIGN_OR_RETURN_UNWRAP(&ctx, args.Holder());
     ctx->Reset();
-    SetDictionary(ctx);
+    ctx->SetDictionary();
   }
 
   static bool Init(ZCtx* ctx, int level, int windowBits, int memLevel,
@@ -577,51 +577,47 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
     return true;
   }
 
-  static void SetDictionary(ZCtx* ctx) {
-    if (ctx->dictionary_ == nullptr)
+  void SetDictionary() {
+    if (dictionary_ == nullptr)
       return;
 
-    ctx->err_ = Z_OK;
+    err_ = Z_OK;
 
-    switch (ctx->mode_) {
+    switch (mode_) {
       case DEFLATE:
       case DEFLATERAW:
-        ctx->err_ = deflateSetDictionary(&ctx->strm_,
-                                         ctx->dictionary_,
-                                         ctx->dictionary_len_);
+        err_ = deflateSetDictionary(&strm_, dictionary_, dictionary_len_);
         break;
       case INFLATERAW:
         // The other inflate cases will have the dictionary set when inflate()
         // returns Z_NEED_DICT in Process()
-        ctx->err_ = inflateSetDictionary(&ctx->strm_,
-                                         ctx->dictionary_,
-                                         ctx->dictionary_len_);
+        err_ = inflateSetDictionary(&strm_, dictionary_, dictionary_len_);
         break;
       default:
         break;
     }
 
-    if (ctx->err_ != Z_OK) {
-      ctx->Error("Failed to set dictionary");
+    if (err_ != Z_OK) {
+      Error("Failed to set dictionary");
     }
   }
 
-  static void Params(ZCtx* ctx, int level, int strategy) {
-    AllocScope alloc_scope(ctx);
+  void Params(int level, int strategy) {
+    AllocScope alloc_scope(this);
 
-    ctx->err_ = Z_OK;
+    err_ = Z_OK;
 
-    switch (ctx->mode_) {
+    switch (mode_) {
       case DEFLATE:
       case DEFLATERAW:
-        ctx->err_ = deflateParams(&ctx->strm_, level, strategy);
+        err_ = deflateParams(&strm_, level, strategy);
         break;
       default:
         break;
     }
 
-    if (ctx->err_ != Z_OK && ctx->err_ != Z_BUF_ERROR) {
-      ctx->Error("Failed to set parameters");
+    if (err_ != Z_OK && err_ != Z_BUF_ERROR) {
+      Error("Failed to set parameters");
     }
   }
 

From 07cce880bfd6cf6d17a499798d2699617e13750d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= <tniessen@tnie.de>
Date: Tue, 12 Jun 2018 14:15:38 +0200
Subject: [PATCH 051/116] crypto: handle OpenSSL error queue in CipherBase

This handles all errors produced by OpenSSL within the CipherBase
class. API functions ensure that they do not add any new errors to the
error queue. Also adds a couple of CHECKs and throws under certain
conditions.

PR-URL: https://github.com/nodejs/node/pull/21288
Fixes: https://github.com/nodejs/node/issues/21281
Refs: https://github.com/nodejs/node/pull/21287
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
---
 src/node_crypto.cc | 57 +++++++++++++++++++++++++++++++---------------
 1 file changed, 39 insertions(+), 18 deletions(-)

diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 20975513f53911..ba65876e486a93 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -2581,6 +2581,7 @@ void CipherBase::Init(const char* cipher_type,
                       int key_buf_len,
                       unsigned int auth_tag_len) {
   HandleScope scope(env()->isolate());
+  MarkPopErrorOnReturn mark_pop_error_on_return;
 
 #ifdef NODE_FIPS_MODE
   if (FIPS_mode()) {
@@ -2605,6 +2606,7 @@ void CipherBase::Init(const char* cipher_type,
                                1,
                                key,
                                iv);
+  CHECK_NE(key_len, 0);
 
   ctx_.reset(EVP_CIPHER_CTX_new());
 
@@ -2613,7 +2615,11 @@ void CipherBase::Init(const char* cipher_type,
     EVP_CIPHER_CTX_set_flags(ctx_.get(), EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
 
   const bool encrypt = (kind_ == kCipher);
-  EVP_CipherInit_ex(ctx_.get(), cipher, nullptr, nullptr, nullptr, encrypt);
+  if (1 != EVP_CipherInit_ex(ctx_.get(), cipher, nullptr,
+                             nullptr, nullptr, encrypt)) {
+    return ThrowCryptoError(env(), ERR_get_error(),
+                            "Failed to initialize cipher");
+  }
 
   if (encrypt && (mode == EVP_CIPH_CTR_MODE || mode == EVP_CIPH_GCM_MODE ||
       mode == EVP_CIPH_CCM_MODE)) {
@@ -2632,12 +2638,15 @@ void CipherBase::Init(const char* cipher_type,
 
   CHECK_EQ(1, EVP_CIPHER_CTX_set_key_length(ctx_.get(), key_len));
 
-  EVP_CipherInit_ex(ctx_.get(),
-                    nullptr,
-                    nullptr,
-                    reinterpret_cast<unsigned char*>(key),
-                    reinterpret_cast<unsigned char*>(iv),
-                    encrypt);
+  if (1 != EVP_CipherInit_ex(ctx_.get(),
+                             nullptr,
+                             nullptr,
+                             reinterpret_cast<unsigned char*>(key),
+                             reinterpret_cast<unsigned char*>(iv),
+                             encrypt)) {
+    return ThrowCryptoError(env(), ERR_get_error(),
+                            "Failed to initialize cipher");
+  }
 }
 
 
@@ -2672,6 +2681,7 @@ void CipherBase::InitIv(const char* cipher_type,
                         int iv_len,
                         unsigned int auth_tag_len) {
   HandleScope scope(env()->isolate());
+  MarkPopErrorOnReturn mark_pop_error_on_return;
 
   const EVP_CIPHER* const cipher = EVP_get_cipherbyname(cipher_type);
   if (cipher == nullptr) {
@@ -2702,7 +2712,11 @@ void CipherBase::InitIv(const char* cipher_type,
     EVP_CIPHER_CTX_set_flags(ctx_.get(), EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
 
   const bool encrypt = (kind_ == kCipher);
-  EVP_CipherInit_ex(ctx_.get(), cipher, nullptr, nullptr, nullptr, encrypt);
+  if (1 != EVP_CipherInit_ex(ctx_.get(), cipher, nullptr,
+                             nullptr, nullptr, encrypt)) {
+    return ThrowCryptoError(env(), ERR_get_error(),
+                            "Failed to initialize cipher");
+  }
 
   if (IsAuthenticatedMode()) {
     CHECK(has_iv);
@@ -2715,12 +2729,15 @@ void CipherBase::InitIv(const char* cipher_type,
     return env()->ThrowError("Invalid key length");
   }
 
-  EVP_CipherInit_ex(ctx_.get(),
-                    nullptr,
-                    nullptr,
-                    reinterpret_cast<const unsigned char*>(key),
-                    reinterpret_cast<const unsigned char*>(iv),
-                    encrypt);
+  if (1 != EVP_CipherInit_ex(ctx_.get(),
+                             nullptr,
+                             nullptr,
+                             reinterpret_cast<const unsigned char*>(key),
+                             reinterpret_cast<const unsigned char*>(iv),
+                             encrypt)) {
+    return ThrowCryptoError(env(), ERR_get_error(),
+                            "Failed to initialize cipher");
+  }
 }
 
 
@@ -2765,6 +2782,7 @@ static bool IsValidGCMTagLength(unsigned int tag_len) {
 bool CipherBase::InitAuthenticated(const char* cipher_type, int iv_len,
                                    unsigned int auth_tag_len) {
   CHECK(IsAuthenticatedMode());
+  MarkPopErrorOnReturn mark_pop_error_on_return;
 
   if (!EVP_CIPHER_CTX_ctrl(ctx_.get(),
                            EVP_CTRL_AEAD_SET_IVLEN,
@@ -2910,6 +2928,7 @@ void CipherBase::SetAuthTag(const FunctionCallbackInfo<Value>& args) {
 bool CipherBase::SetAAD(const char* data, unsigned int len, int plaintext_len) {
   if (!ctx_ || !IsAuthenticatedMode())
     return false;
+  MarkPopErrorOnReturn mark_pop_error_on_return;
 
   int outlen;
   const int mode = EVP_CIPHER_CTX_mode(ctx_.get());
@@ -2969,6 +2988,7 @@ CipherBase::UpdateResult CipherBase::Update(const char* data,
                                             int* out_len) {
   if (!ctx_)
     return kErrorState;
+  MarkPopErrorOnReturn mark_pop_error_on_return;
 
   const int mode = EVP_CIPHER_CTX_mode(ctx_.get());
 
@@ -2980,10 +3000,10 @@ CipherBase::UpdateResult CipherBase::Update(const char* data,
   // on first update:
   if (kind_ == kDecipher && IsAuthenticatedMode() && auth_tag_len_ > 0 &&
       auth_tag_len_ != kNoAuthTagLength && !auth_tag_set_) {
-    EVP_CIPHER_CTX_ctrl(ctx_.get(),
-                        EVP_CTRL_GCM_SET_TAG,
-                        auth_tag_len_,
-                        reinterpret_cast<unsigned char*>(auth_tag_));
+    CHECK(EVP_CIPHER_CTX_ctrl(ctx_.get(),
+                              EVP_CTRL_GCM_SET_TAG,
+                              auth_tag_len_,
+                              reinterpret_cast<unsigned char*>(auth_tag_)));
     auth_tag_set_ = true;
   }
 
@@ -3061,6 +3081,7 @@ void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
 bool CipherBase::SetAutoPadding(bool auto_padding) {
   if (!ctx_)
     return false;
+  MarkPopErrorOnReturn mark_pop_error_on_return;
   return EVP_CIPHER_CTX_set_padding(ctx_.get(), auto_padding);
 }
 

From 27d17d460013e256b6993707bbb6764391cba93b Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 22 Jun 2018 12:50:01 -0700
Subject: [PATCH 052/116] trace_events: add traced_value.cc/traced_value.h

Port of the V8 internal v8::tracing::TracedValue that allows
structured data to be included in the trace event. The v8 class
is not exported in the public API so we cannot use it directly.

This is a simplified and slightly modified port. This commit only
adds the class, it does not add uses of it. Those will come in
separate PRs/commits.

PR-URL: https://github.com/nodejs/node/pull/21475
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 node.gyp                         |   3 +
 src/tracing/traced_value.cc      | 224 +++++++++++++++++++++++++++++++
 src/tracing/traced_value.h       |  68 ++++++++++
 test/cctest/test_traced_value.cc |  96 +++++++++++++
 4 files changed, 391 insertions(+)
 create mode 100644 src/tracing/traced_value.cc
 create mode 100644 src/tracing/traced_value.h
 create mode 100644 test/cctest/test_traced_value.cc

diff --git a/node.gyp b/node.gyp
index 207c72cdb56a29..35a81437afdfcf 100644
--- a/node.gyp
+++ b/node.gyp
@@ -377,6 +377,7 @@
         'src/tracing/node_trace_buffer.cc',
         'src/tracing/node_trace_writer.cc',
         'src/tracing/trace_event.cc',
+        'src/tracing/traced_value.cc',
         'src/tty_wrap.cc',
         'src/udp_wrap.cc',
         'src/util.cc',
@@ -437,6 +438,7 @@
         'src/tracing/node_trace_buffer.h',
         'src/tracing/node_trace_writer.h',
         'src/tracing/trace_event.h',
+        'src/tracing/traced_value.h',
         'src/util.h',
         'src/util-inl.h',
         'deps/http_parser/http_parser.h',
@@ -950,6 +952,7 @@
         'test/cctest/test_node_postmortem_metadata.cc',
         'test/cctest/test_environment.cc',
         'test/cctest/test_platform.cc',
+        'test/cctest/test_traced_value.cc',
         'test/cctest/test_util.cc',
         'test/cctest/test_url.cc'
       ],
diff --git a/src/tracing/traced_value.cc b/src/tracing/traced_value.cc
new file mode 100644
index 00000000000000..e256df267eb5a9
--- /dev/null
+++ b/src/tracing/traced_value.cc
@@ -0,0 +1,224 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "tracing/traced_value.h"
+
+#include <math.h>
+#include <sstream>
+#include <stdio.h>
+#include <string>
+
+#if defined(NODE_HAVE_I18N_SUPPORT)
+#include <unicode/utf8.h>
+#include <unicode/utypes.h>
+#endif
+
+#if defined(_STLP_VENDOR_CSTD)
+// STLPort doesn't import fpclassify into the std namespace.
+#define FPCLASSIFY_NAMESPACE
+#else
+#define FPCLASSIFY_NAMESPACE std
+#endif
+
+namespace node {
+namespace tracing {
+
+namespace {
+
+std::string EscapeString(const char* value) {
+  std::string result;
+  result += '"';
+  char number_buffer[10];
+#if defined(NODE_HAVE_I18N_SUPPORT)
+  int32_t len = strlen(value);
+  int32_t p = 0;
+  int32_t i = 0;
+  for (; i < len; p = i) {
+    UChar32 c;
+    U8_NEXT_OR_FFFD(value, i, len, c);
+    switch (c) {
+      case '\b': result += "\\b"; break;
+      case '\f': result += "\\f"; break;
+      case '\n': result += "\\n"; break;
+      case '\r': result += "\\r"; break;
+      case '\t': result += "\\t"; break;
+      case '\\': result += "\\\\"; break;
+      case '"': result += "\\\""; break;
+      default:
+        if (c < 32 || c > 126) {
+          snprintf(
+              number_buffer, arraysize(number_buffer), "\\u%04X",
+              static_cast<uint16_t>(static_cast<uint16_t>(c)));
+          result += number_buffer;
+        } else {
+          result.append(value + p, i - p);
+        }
+    }
+  }
+#else
+  // If we do not have ICU, use a modified version of the non-UTF8 aware
+  // code from V8's own TracedValue implementation. Note, however, This
+  // will not produce correctly serialized results for UTF8 values.
+  while (*value) {
+    char c = *value++;
+    switch (c) {
+      case '\b': result += "\\b"; break;
+      case '\f': result += "\\f"; break;
+      case '\n': result += "\\n"; break;
+      case '\r': result += "\\r"; break;
+      case '\t': result += "\\t"; break;
+      case '\\': result += "\\\\"; break;
+      case '"': result += "\\\""; break;
+      default:
+        if (c < '\x20') {
+          snprintf(
+              number_buffer, arraysize(number_buffer), "\\u%04X",
+              static_cast<unsigned>(static_cast<unsigned char>(c)));
+          result += number_buffer;
+        } else {
+          result += c;
+        }
+    }
+  }
+#endif  // defined(NODE_HAVE_I18N_SUPPORT)
+  result += '"';
+  return result;
+}
+
+std::string DoubleToCString(double v) {
+  switch (FPCLASSIFY_NAMESPACE::fpclassify(v)) {
+    case FP_NAN: return "\"NaN\"";
+    case FP_INFINITE: return (v < 0.0 ? "\"-Infinity\"" : "\"Infinity\"");
+    case FP_ZERO: return "0";
+    default:
+      // This is a far less sophisticated version than the one used inside v8.
+      std::ostringstream stream;
+      stream.imbue(std::locale("C"));  // Ignore locale
+      stream << v;
+      return stream.str();
+  }
+}
+
+}  // namespace
+
+std::unique_ptr<TracedValue> TracedValue::Create() {
+  return std::unique_ptr<TracedValue>(new TracedValue(false));
+}
+
+std::unique_ptr<TracedValue> TracedValue::CreateArray() {
+  return std::unique_ptr<TracedValue>(new TracedValue(true));
+}
+
+TracedValue::TracedValue(bool root_is_array) :
+    first_item_(true), root_is_array_(root_is_array) {}
+
+TracedValue::~TracedValue() {}
+
+void TracedValue::SetInteger(const char* name, int value) {
+  WriteName(name);
+  data_ += std::to_string(value);
+}
+
+void TracedValue::SetDouble(const char* name, double value) {
+  WriteName(name);
+  data_ += DoubleToCString(value);
+}
+
+void TracedValue::SetBoolean(const char* name, bool value) {
+  WriteName(name);
+  data_ += value ? "true" : "false";
+}
+
+void TracedValue::SetNull(const char* name) {
+  WriteName(name);
+  data_ += "null";
+}
+
+void TracedValue::SetString(const char* name, const char* value) {
+  WriteName(name);
+  data_ += EscapeString(value);
+}
+
+void TracedValue::BeginDictionary(const char* name) {
+  WriteName(name);
+  data_ += '{';
+  first_item_ = true;
+}
+
+void TracedValue::BeginArray(const char* name) {
+  WriteName(name);
+  data_ += '[';
+  first_item_ = true;
+}
+
+void TracedValue::AppendInteger(int value) {
+  WriteComma();
+  data_ += std::to_string(value);
+}
+
+void TracedValue::AppendDouble(double value) {
+  WriteComma();
+  data_ += DoubleToCString(value);
+}
+
+void TracedValue::AppendBoolean(bool value) {
+  WriteComma();
+  data_ += value ? "true" : "false";
+}
+
+void TracedValue::AppendNull() {
+  WriteComma();
+  data_ += "null";
+}
+
+void TracedValue::AppendString(const char* value) {
+  WriteComma();
+  data_ += EscapeString(value);
+}
+
+void TracedValue::BeginDictionary() {
+  WriteComma();
+  data_ += '{';
+  first_item_ = true;
+}
+
+void TracedValue::BeginArray() {
+  WriteComma();
+  data_ += '[';
+  first_item_ = true;
+}
+
+void TracedValue::EndDictionary() {
+  data_ += '}';
+  first_item_ = false;
+}
+
+void TracedValue::EndArray() {
+  data_ += ']';
+  first_item_ = false;
+}
+
+void TracedValue::WriteComma() {
+  if (first_item_) {
+    first_item_ = false;
+  } else {
+    data_ += ',';
+  }
+}
+
+void TracedValue::WriteName(const char* name) {
+  WriteComma();
+  data_ += '"';
+  data_ += name;
+  data_ += "\":";
+}
+
+void TracedValue::AppendAsTraceFormat(std::string* out) const {
+  *out += root_is_array_ ? '[' : '{';
+  *out += data_;
+  *out += root_is_array_ ? ']' : '}';
+}
+
+}  // namespace tracing
+}  // namespace node
diff --git a/src/tracing/traced_value.h b/src/tracing/traced_value.h
new file mode 100644
index 00000000000000..84e24c952528f5
--- /dev/null
+++ b/src/tracing/traced_value.h
@@ -0,0 +1,68 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_TRACING_TRACED_VALUE_H_
+#define SRC_TRACING_TRACED_VALUE_H_
+
+#include "node_internals.h"
+#include "v8.h"
+
+#include <stddef.h>
+#include <memory>
+#include <string>
+
+namespace node {
+namespace tracing {
+
+class TracedValue : public v8::ConvertableToTraceFormat {
+ public:
+  ~TracedValue() override;
+
+  static std::unique_ptr<TracedValue> Create();
+  static std::unique_ptr<TracedValue> CreateArray();
+
+  void EndDictionary();
+  void EndArray();
+
+  // These methods assume that |name| is a long lived "quoted" string.
+  void SetInteger(const char* name, int value);
+  void SetDouble(const char* name, double value);
+  void SetBoolean(const char* name, bool value);
+  void SetNull(const char* name);
+  void SetString(const char* name, const char* value);
+  void SetString(const char* name, const std::string& value) {
+    SetString(name, value.c_str());
+  }
+  void BeginDictionary(const char* name);
+  void BeginArray(const char* name);
+
+  void AppendInteger(int);
+  void AppendDouble(double);
+  void AppendBoolean(bool);
+  void AppendNull();
+  void AppendString(const char*);
+  void AppendString(const std::string& value) { AppendString(value.c_str()); }
+  void BeginArray();
+  void BeginDictionary();
+
+  // ConvertableToTraceFormat implementation.
+  void AppendAsTraceFormat(std::string* out) const override;
+
+ private:
+  explicit TracedValue(bool root_is_array = false);
+
+  void WriteComma();
+  void WriteName(const char* name);
+
+  std::string data_;
+  bool first_item_;
+  bool root_is_array_;
+
+  DISALLOW_COPY_AND_ASSIGN(TracedValue);
+};
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // SRC_TRACING_TRACED_VALUE_H_
diff --git a/test/cctest/test_traced_value.cc b/test/cctest/test_traced_value.cc
new file mode 100644
index 00000000000000..5329c78446ca6f
--- /dev/null
+++ b/test/cctest/test_traced_value.cc
@@ -0,0 +1,96 @@
+#include "tracing/traced_value.h"
+
+#include <math.h>
+#include <stddef.h>
+#include <string.h>
+
+#include "gtest/gtest.h"
+
+using node::tracing::TracedValue;
+
+TEST(TracedValue, Object) {
+  auto traced_value = TracedValue::Create();
+  traced_value->SetString("a", "b");
+  traced_value->SetInteger("b", 1);
+  traced_value->SetDouble("c", 1.234);
+  traced_value->SetDouble("d", NAN);
+  traced_value->SetDouble("e", INFINITY);
+  traced_value->SetDouble("f", -INFINITY);
+  traced_value->SetDouble("g", 1.23e7);
+  traced_value->SetBoolean("h", false);
+  traced_value->SetBoolean("i", true);
+  traced_value->SetNull("j");
+  traced_value->BeginDictionary("k");
+  traced_value->SetString("l", "m");
+  traced_value->EndDictionary();
+
+  std::string string;
+  traced_value->AppendAsTraceFormat(&string);
+
+  static const char* check = "{\"a\":\"b\",\"b\":1,\"c\":1.234,\"d\":\"NaN\","
+                             "\"e\":\"Infinity\",\"f\":\"-Infinity\",\"g\":"
+                             "1.23e+07,\"h\":false,\"i\":true,\"j\":null,\"k\":"
+                             "{\"l\":\"m\"}}";
+
+  EXPECT_EQ(check, string);
+}
+
+TEST(TracedValue, Array) {
+  auto traced_value = TracedValue::CreateArray();
+  traced_value->AppendString("a");
+  traced_value->AppendInteger(1);
+  traced_value->AppendDouble(1.234);
+  traced_value->AppendDouble(NAN);
+  traced_value->AppendDouble(INFINITY);
+  traced_value->AppendDouble(-INFINITY);
+  traced_value->AppendDouble(1.23e7);
+  traced_value->AppendBoolean(false);
+  traced_value->AppendBoolean(true);
+  traced_value->AppendNull();
+  traced_value->BeginDictionary();
+  traced_value->BeginArray("foo");
+  traced_value->EndArray();
+  traced_value->EndDictionary();
+
+  std::string string;
+  traced_value->AppendAsTraceFormat(&string);
+
+  static const char* check = "[\"a\",1,1.234,\"NaN\",\"Infinity\","
+                             "\"-Infinity\",1.23e+07,false,true,null,"
+                             "{\"foo\":[]}]";
+
+  EXPECT_EQ(check, string);
+}
+
+#define UTF8_SEQUENCE "1" "\xE2\x82\xAC" "23\"\x01\b\f\n\r\t\\"
+#if defined(NODE_HAVE_I18N_SUPPORT)
+# define UTF8_RESULT                                                          \
+  "\"1\\u20AC23\\\"\\u0001\\b\\f\\n\\r\\t\\\\\""
+#else
+# define UTF8_RESULT                                                          \
+  "\"1\\u00E2\\u0082\\u00AC23\\\"\\u0001\\b\\f\\n\\r\\t\\\\\""
+#endif
+
+TEST(TracedValue, EscapingObject) {
+  auto traced_value = TracedValue::Create();
+  traced_value->SetString("a", UTF8_SEQUENCE);
+
+  std::string string;
+  traced_value->AppendAsTraceFormat(&string);
+
+  static const char* check = "{\"a\":" UTF8_RESULT "}";
+
+  EXPECT_EQ(check, string);
+}
+
+TEST(TracedValue, EscapingArray) {
+  auto traced_value = TracedValue::CreateArray();
+  traced_value->AppendString(UTF8_SEQUENCE);
+
+  std::string string;
+  traced_value->AppendAsTraceFormat(&string);
+
+  static const char* check = "[" UTF8_RESULT "]";
+
+  EXPECT_EQ(check, string);
+}

From 3096ee5a4b6e1ee56d1b4c1776975f26381e8a38 Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Fri, 8 Jun 2018 22:41:20 -0500
Subject: [PATCH 053/116] napi: add bigint support

PR-URL: https://github.com/nodejs/node/pull/21226
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
---
 doc/api/n-api.md                           | 164 ++++++++++++++++++++-
 src/node_api.cc                            | 137 ++++++++++++++++-
 src/node_api.h                             |  24 +++
 src/node_api_types.h                       |   4 +
 test/addons-napi/test_bigint/binding.gyp   |   8 +
 test/addons-napi/test_bigint/test.js       |  45 ++++++
 test/addons-napi/test_bigint/test_bigint.c | 142 ++++++++++++++++++
 test/addons-napi/test_typedarray/test.js   |   5 +-
 8 files changed, 523 insertions(+), 6 deletions(-)
 create mode 100644 test/addons-napi/test_bigint/binding.gyp
 create mode 100644 test/addons-napi/test_bigint/test.js
 create mode 100644 test/addons-napi/test_bigint/test_bigint.c

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index cdb3fcaf8276bf..5fbe4bb07469c2 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -113,10 +113,9 @@ typedef enum {
   napi_escape_called_twice,
   napi_handle_scope_mismatch,
   napi_callback_scope_mismatch,
-#ifdef NAPI_EXPERIMENTAL
   napi_queue_full,
   napi_closing,
-#endif  // NAPI_EXPERIMENTAL
+  napi_bigint_expected,
 } napi_status;
 ```
 If additional information is required upon an API returning a failed status,
@@ -1225,6 +1224,7 @@ typedef enum {
   napi_object,
   napi_function,
   napi_external,
+  napi_bigint,
 } napi_valuetype;
 ```
 
@@ -1250,6 +1250,8 @@ typedef enum {
   napi_uint32_array,
   napi_float32_array,
   napi_float64_array,
+  napi_bigint64_array,
+  napi_biguint64_array,
 } napi_typedarray_type;
 ```
 
@@ -1691,6 +1693,78 @@ This API is used to convert from the C `double` type to the JavaScript
 The JavaScript `Number` type is described in
 [Section 6.1.6][] of the ECMAScript Language Specification.
 
+#### napi_create_bigint_int64
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_create_bigint_int64(napi_env env,
+                                     int64_t value,
+                                     napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Integer value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript `BigInt`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API converts the C `int64_t` type to the JavaScript `BigInt` type.
+
+#### napi_create_bigint_uint64
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_create_bigint_uint64(napi_env env,
+                                      uint64_t vaue,
+                                      napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Unsigned integer value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript `BigInt`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API converts the C `uint64_t` type to the JavaScript `BigInt` type.
+
+#### napi_create_bigint_words
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_create_bigint_words(napi_env env,
+                                     int sign_bit,
+                                     size_t word_count,
+                                     const uint64_t* words,
+                                     napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] sign_bit`: Determines if the resulting `BigInt` will be positive or
+  negative.
+- `[in] word_count`: The length of the `words` array.
+- `[in] words`: An array of `uint64_t` little-endian 64-bit words.
+- `[out] result`: A `napi_value` representing a JavaScript `BigInt`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API converts an array of unsigned 64-bit words into a single `BigInt`
+value.
+
+The resulting `BigInt` is calculated as: (–1)<sup>`sign_bit`</sup> (`words[0]`
+× (2<sup>64</sup>)<sup>0</sup> + `words[1]` × (2<sup>64</sup>)<sup>1</sup> + …)
+
 #### napi_create_string_latin1
 <!-- YAML
 added: v8.0.0
@@ -1975,6 +2049,92 @@ in it returns `napi_number_expected`.
 This API returns the C double primitive equivalent of the given JavaScript
 `Number`.
 
+#### napi_get_value_bigint_int64
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_get_value_bigint_int64(napi_env env,
+                                        napi_value value,
+                                        int64_t* result,
+                                        bool* lossless);
+```
+
+- `[in] env`: The environment that the API is invoked under
+- `[in] value`: `napi_value` representing JavaScript `BigInt`.
+- `[out] result`: C `int64_t` primitive equivalent of the given JavaScript
+  `BigInt`.
+- `[out] lossless`: Indicates whether the `BigInt` value was converted
+  losslessly.
+
+Returns `napi_ok` if the API succeeded. If a non-`BigInt` is passed in it
+returns `napi_bigint_expected`.
+
+This API returns the C `int64_t` primitive equivalent of the given JavaScript
+`BigInt`. If needed it will truncate the value, setting `lossless` to `false`.
+
+
+#### napi_get_value_bigint_uint64
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_get_value_bigint_uint64(napi_env env,
+                                        napi_value value,
+                                        uint64_t* result,
+                                        bool* lossless);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript `BigInt`.
+- `[out] result`: C `uint64_t` primitive equivalent of the given JavaScript
+  `BigInt`.
+- `[out] lossless`: Indicates whether the `BigInt` value was converted
+  losslessly.
+
+Returns `napi_ok` if the API succeeded. If a non-`BigInt` is passed in it
+returns `napi_bigint_expected`.
+
+This API returns the C `uint64_t` primitive equivalent of the given JavaScript
+`BigInt`. If needed it will truncate the value, setting `lossless` to `false`.
+
+
+#### napi_get_value_bigint_words
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+```C
+napi_status napi_get_value_bigint_words(napi_env env,
+                                        napi_value value,
+                                        size_t* word_count,
+                                        int* sign_bit,
+                                        uint64_t* words);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript `BigInt`.
+- `[out] sign_bit`: Integer representing if the JavaScript `BigInt` is positive
+   or negative.
+- `[in/out] word_count`: Must be initialized to the length of the `words`
+   array. Upon return, it will be set to the actual number of words that
+   would be needed to store this `BigInt`.
+- `[out] words`: Pointer to a pre-allocated 64-bit word array.
+
+Returns `napi_ok` if the API succeeded.
+
+This API converts a single `BigInt` value into a sign bit, 64-bit little-endian
+array, and the number of elements in the array. `sign_bit` and `words` may be
+both set to `NULL`, in order to get only `word_count`.
+
 #### napi_get_value_external
 <!-- YAML
 added: v8.0.0
diff --git a/src/node_api.cc b/src/node_api.cc
index 1d42435264cfec..ad0796570a4c14 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -926,7 +926,8 @@ const char* error_messages[] = {nullptr,
                                 "Invalid handle scope usage",
                                 "Invalid callback scope usage",
                                 "Thread-safe function queue is full",
-                                "Thread-safe function handle is closing"
+                                "Thread-safe function handle is closing",
+                                "A bigint was expected",
 };
 
 static inline napi_status napi_clear_last_error(napi_env env) {
@@ -958,7 +959,7 @@ napi_status napi_get_last_error_info(napi_env env,
   // We don't have a napi_status_last as this would result in an ABI
   // change each time a message was added.
   static_assert(
-      node::arraysize(error_messages) == napi_closing + 1,
+      node::arraysize(error_messages) == napi_bigint_expected + 1,
       "Count of error messages must match count of error values");
   CHECK_LE(env->last_error.error_code, napi_callback_scope_mismatch);
 
@@ -1713,6 +1714,58 @@ napi_status napi_create_int64(napi_env env,
   return napi_clear_last_error(env);
 }
 
+napi_status napi_create_bigint_int64(napi_env env,
+                                     int64_t value,
+                                     napi_value* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::BigInt::New(env->isolate, value));
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_create_bigint_uint64(napi_env env,
+                                      uint64_t value,
+                                      napi_value* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::BigInt::NewFromUnsigned(env->isolate, value));
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_create_bigint_words(napi_env env,
+                                     int sign_bit,
+                                     size_t word_count,
+                                     const uint64_t* words,
+                                     napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, words);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+
+  if (word_count > INT_MAX) {
+    napi_throw_range_error(env, nullptr, "Maximum BigInt size exceeded");
+    return napi_set_last_error(env, napi_pending_exception);
+  }
+
+  v8::MaybeLocal<v8::BigInt> b = v8::BigInt::NewFromWords(
+      context, sign_bit, word_count, words);
+
+  if (try_catch.HasCaught()) {
+    return napi_set_last_error(env, napi_pending_exception);
+  } else {
+    CHECK_MAYBE_EMPTY(env, b, napi_generic_failure);
+    *result = v8impl::JsValueFromV8LocalValue(b.ToLocalChecked());
+    return napi_clear_last_error(env);
+  }
+}
+
 napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
   CHECK_ENV(env);
   CHECK_ARG(env, result);
@@ -1878,6 +1931,8 @@ napi_status napi_typeof(napi_env env,
 
   if (v->IsNumber()) {
     *result = napi_number;
+  } else if (v->IsBigInt()) {
+    *result = napi_bigint;
   } else if (v->IsString()) {
     *result = napi_string;
   } else if (v->IsFunction()) {
@@ -2201,6 +2256,72 @@ napi_status napi_get_value_int64(napi_env env,
   return napi_clear_last_error(env);
 }
 
+napi_status napi_get_value_bigint_int64(napi_env env,
+                                        napi_value value,
+                                        int64_t* result,
+                                        bool* lossless) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
+  CHECK_ARG(env, lossless);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected);
+
+  *result = val.As<v8::BigInt>()->Int64Value(lossless);
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_get_value_bigint_uint64(napi_env env,
+                                         napi_value value,
+                                         uint64_t* result,
+                                         bool* lossless) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
+  CHECK_ARG(env, lossless);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected);
+
+  *result = val.As<v8::BigInt>()->Uint64Value(lossless);
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_get_value_bigint_words(napi_env env,
+                                        napi_value value,
+                                        int* sign_bit,
+                                        size_t* word_count,
+                                        uint64_t* words) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, word_count);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  RETURN_STATUS_IF_FALSE(env, val->IsBigInt(), napi_bigint_expected);
+
+  v8::Local<v8::BigInt> big = val.As<v8::BigInt>();
+
+  int word_count_int = *word_count;
+
+  if (sign_bit == nullptr && words == nullptr) {
+    word_count_int = big->WordCount();
+  } else {
+    CHECK_ARG(env, sign_bit);
+    CHECK_ARG(env, words);
+    big->ToWordsArray(sign_bit, &word_count_int, words);
+  }
+
+  *word_count = word_count_int;
+
+  return napi_clear_last_error(env);
+}
+
 napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
@@ -3139,6 +3260,14 @@ napi_status napi_create_typedarray(napi_env env,
       CREATE_TYPED_ARRAY(
           env, Float64Array, 8, buffer, byte_offset, length, typedArray);
       break;
+    case napi_bigint64_array:
+      CREATE_TYPED_ARRAY(
+          env, BigInt64Array, 8, buffer, byte_offset, length, typedArray);
+      break;
+    case napi_biguint64_array:
+      CREATE_TYPED_ARRAY(
+          env, BigUint64Array, 8, buffer, byte_offset, length, typedArray);
+      break;
     default:
       return napi_set_last_error(env, napi_invalid_arg);
   }
@@ -3181,6 +3310,10 @@ napi_status napi_get_typedarray_info(napi_env env,
       *type = napi_float32_array;
     } else if (value->IsFloat64Array()) {
       *type = napi_float64_array;
+    } else if (value->IsBigInt64Array()) {
+      *type = napi_bigint64_array;
+    } else if (value->IsBigUint64Array()) {
+      *type = napi_biguint64_array;
     }
   }
 
diff --git a/src/node_api.h b/src/node_api.h
index b22592db15f110..1b2a392a0a0b1c 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -671,6 +671,30 @@ napi_unref_threadsafe_function(napi_env env, napi_threadsafe_function func);
 NAPI_EXTERN napi_status
 napi_ref_threadsafe_function(napi_env env, napi_threadsafe_function func);
 
+NAPI_EXTERN napi_status napi_create_bigint_int64(napi_env env,
+                                                 int64_t value,
+                                                 napi_value* result);
+NAPI_EXTERN napi_status napi_create_bigint_uint64(napi_env env,
+                                                  uint64_t value,
+                                                  napi_value* result);
+NAPI_EXTERN napi_status napi_create_bigint_words(napi_env env,
+                                                 int sign_bit,
+                                                 size_t word_count,
+                                                 const uint64_t* words,
+                                                 napi_value* result);
+NAPI_EXTERN napi_status napi_get_value_bigint_int64(napi_env env,
+                                                    napi_value value,
+                                                    int64_t* result,
+                                                    bool* lossless);
+NAPI_EXTERN napi_status napi_get_value_bigint_uint64(napi_env env,
+                                                     napi_value value,
+                                                     uint64_t* result,
+                                                     bool* lossless);
+NAPI_EXTERN napi_status napi_get_value_bigint_words(napi_env env,
+                                                    napi_value value,
+                                                    int* sign_bit,
+                                                    size_t* word_count,
+                                                    uint64_t* words);
 #endif  // NAPI_EXPERIMENTAL
 
 EXTERN_C_END
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 3854a32f011048..10215d9aa3a0ff 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -46,6 +46,7 @@ typedef enum {
   napi_object,
   napi_function,
   napi_external,
+  napi_bigint,
 } napi_valuetype;
 
 typedef enum {
@@ -58,6 +59,8 @@ typedef enum {
   napi_uint32_array,
   napi_float32_array,
   napi_float64_array,
+  napi_bigint64_array,
+  napi_biguint64_array,
 } napi_typedarray_type;
 
 typedef enum {
@@ -78,6 +81,7 @@ typedef enum {
   napi_callback_scope_mismatch,
   napi_queue_full,
   napi_closing,
+  napi_bigint_expected,
 } napi_status;
 
 #ifdef NAPI_EXPERIMENTAL
diff --git a/test/addons-napi/test_bigint/binding.gyp b/test/addons-napi/test_bigint/binding.gyp
new file mode 100644
index 00000000000000..1b9f75bab4f737
--- /dev/null
+++ b/test/addons-napi/test_bigint/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_bigint",
+      "sources": [ "test_bigint.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_bigint/test.js b/test/addons-napi/test_bigint/test.js
new file mode 100644
index 00000000000000..b92c810459321b
--- /dev/null
+++ b/test/addons-napi/test_bigint/test.js
@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const {
+  IsLossless,
+  TestInt64,
+  TestUint64,
+  TestWords,
+  CreateTooBigBigInt,
+} = require(`./build/${common.buildType}/test_bigint`);
+
+[
+  0n,
+  -0n,
+  1n,
+  -1n,
+  100n,
+  2121n,
+  -1233n,
+  986583n,
+  -976675n,
+  98765432213456789876546896323445679887645323232436587988766545658n,
+  -4350987086545760976737453646576078997096876957864353245245769809n,
+].forEach((num) => {
+  if (num > -(2n ** 63n) && num < 2n ** 63n) {
+    assert.strictEqual(TestInt64(num), num);
+    assert.strictEqual(IsLossless(num, true), true);
+  } else {
+    assert.strictEqual(IsLossless(num, true), false);
+  }
+
+  if (num >= 0 && num < 2n ** 64n) {
+    assert.strictEqual(TestUint64(num), num);
+    assert.strictEqual(IsLossless(num, false), true);
+  } else {
+    assert.strictEqual(IsLossless(num, false), false);
+  }
+
+  assert.strictEqual(num, TestWords(num));
+});
+
+assert.throws(CreateTooBigBigInt, {
+  name: 'RangeError',
+  message: 'Maximum BigInt size exceeded',
+});
diff --git a/test/addons-napi/test_bigint/test_bigint.c b/test/addons-napi/test_bigint/test_bigint.c
new file mode 100644
index 00000000000000..e3516628e88b35
--- /dev/null
+++ b/test/addons-napi/test_bigint/test_bigint.c
@@ -0,0 +1,142 @@
+#define NAPI_EXPERIMENTAL
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <node_api.h>
+#include "../common.h"
+
+static napi_value IsLossless(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, NULL, NULL));
+
+  bool is_signed;
+  NAPI_CALL(env, napi_get_value_bool(env, args[1], &is_signed));
+
+  bool lossless;
+
+  if (is_signed) {
+    int64_t input;
+    NAPI_CALL(env, napi_get_value_bigint_int64(env, args[0], &input, &lossless));
+  } else {
+    uint64_t input;
+    NAPI_CALL(env, napi_get_value_bigint_uint64(env, args[0], &input, &lossless));
+  }
+
+  napi_value output;
+  NAPI_CALL(env, napi_get_boolean(env, lossless, &output));
+
+  return output;
+}
+
+static napi_value TestInt64(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_bigint,
+      "Wrong type of arguments. Expects a bigint as first argument.");
+
+  int64_t input;
+  bool lossless;
+  NAPI_CALL(env, napi_get_value_bigint_int64(env, args[0], &input, &lossless));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_bigint_int64(env, input, &output));
+
+  return output;
+}
+
+static napi_value TestUint64(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_bigint,
+      "Wrong type of arguments. Expects a bigint as first argument.");
+
+  uint64_t input;
+  bool lossless;
+  NAPI_CALL(env, napi_get_value_bigint_uint64(
+        env, args[0], &input, &lossless));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_bigint_uint64(env, input, &output));
+
+  return output;
+}
+
+static napi_value TestWords(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_bigint,
+      "Wrong type of arguments. Expects a bigint as first argument.");
+
+  size_t expected_word_count;
+  NAPI_CALL(env, napi_get_value_bigint_words(
+        env, args[0], NULL, &expected_word_count, NULL));
+
+  int sign_bit;
+  size_t word_count = 10;
+  uint64_t words[10];
+
+  NAPI_CALL(env, napi_get_value_bigint_words(
+        env, args[0], &sign_bit, &word_count, &words));
+
+  NAPI_ASSERT(env, word_count == expected_word_count,
+      "word counts do not match");
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_bigint_words(
+        env, sign_bit, word_count, words, &output));
+
+  return output;
+}
+
+// throws RangeError
+static napi_value CreateTooBigBigInt(napi_env env, napi_callback_info info) {
+  int sign_bit = 0;
+  size_t word_count = SIZE_MAX;
+  uint64_t words[10];
+
+  napi_value output;
+
+  NAPI_CALL(env, napi_create_bigint_words(
+        env, sign_bit, word_count, words, &output));
+
+  return output;
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("IsLossless", IsLossless),
+    DECLARE_NAPI_PROPERTY("TestInt64", TestInt64),
+    DECLARE_NAPI_PROPERTY("TestUint64", TestUint64),
+    DECLARE_NAPI_PROPERTY("TestWords", TestWords),
+    DECLARE_NAPI_PROPERTY("CreateTooBigBigInt", CreateTooBigBigInt),
+  };
+
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index 41915b380be8e8..2a8cf18feb866c 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -42,7 +42,7 @@ assert.strictEqual(externalResult[2], 2);
 const buffer = new ArrayBuffer(128);
 const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,
                      Uint16Array, Int32Array, Uint32Array, Float32Array,
-                     Float64Array ];
+                     Float64Array, BigInt64Array, BigUint64Array ];
 
 arrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
@@ -64,7 +64,8 @@ arrayTypes.forEach((currentType) => {
 });
 
 const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array,
-                            Float32Array, Float64Array ];
+                            Float32Array, Float64Array,
+                            BigInt64Array, BigUint64Array ];
 nonByteArrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
   assert.throws(() => {

From e030dd7d6524641e2184a70ec14d5ddad80fb2c5 Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Sat, 7 Jul 2018 23:32:23 -0500
Subject: [PATCH 054/116] tools: add no-duplicate-requires rule

PR-URL: https://github.com/nodejs/node/pull/21712
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
---
 .eslintrc.js                                  |  2 +
 benchmark/streams/creation.js                 | 10 +--
 doc/api/worker_threads.md                     |  4 +-
 lib/internal/http2/core.js                    |  8 ++-
 lib/internal/modules/esm/translators.js       |  7 +-
 test/.eslintrc.yaml                           |  1 +
 .../test-eslint-duplicate-requires.js         | 25 +++++++
 tools/eslint-rules/no-duplicate-requires.js   | 70 +++++++++++++++++++
 8 files changed, 116 insertions(+), 11 deletions(-)
 create mode 100644 test/parallel/test-eslint-duplicate-requires.js
 create mode 100644 tools/eslint-rules/no-duplicate-requires.js

diff --git a/.eslintrc.js b/.eslintrc.js
index 742f9ea6d38ef9..98568dd9bc4311 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -98,6 +98,7 @@ module.exports = {
     'no-dupe-class-members': 'error',
     'no-dupe-keys': 'error',
     'no-duplicate-case': 'error',
+    'no-duplicate-imports': 'error',
     'no-empty-character-class': 'error',
     'no-ex-assign': 'error',
     'no-extra-boolean-cast': 'error',
@@ -246,6 +247,7 @@ module.exports = {
 
     // Custom rules from eslint-plugin-node-core
     'node-core/no-unescaped-regexp-dot': 'error',
+    'node-core/no-duplicate-requires': 'error',
   },
   globals: {
     Atomics: false,
diff --git a/benchmark/streams/creation.js b/benchmark/streams/creation.js
index 67187f91bd9cb1..46a0a547907c45 100644
--- a/benchmark/streams/creation.js
+++ b/benchmark/streams/creation.js
@@ -1,9 +1,11 @@
 'use strict';
 const common = require('../common.js');
-const Duplex = require('stream').Duplex;
-const Readable = require('stream').Readable;
-const Transform = require('stream').Transform;
-const Writable = require('stream').Writable;
+const {
+  Duplex,
+  Readable,
+  Transform,
+  Writable,
+} = require('stream');
 
 const bench = common.createBenchmark(main, {
   n: [50e6],
diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index d20fd0fce57c80..8b301f42a87620 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -286,7 +286,7 @@ For example:
 ```js
 const assert = require('assert');
 const {
-  Worker, MessageChannel, MessagePort, isMainThread
+  Worker, MessageChannel, MessagePort, isMainThread, parentPort
 } = require('worker_threads');
 if (isMainThread) {
   const worker = new Worker(__filename);
@@ -296,7 +296,7 @@ if (isMainThread) {
     console.log('received:', value);
   });
 } else {
-  require('worker_threads').once('message', (value) => {
+  parentPort.once('message', (value) => {
     assert(value.hereIsYourPort instanceof MessagePort);
     value.hereIsYourPort.postMessage('the worker is sending this');
     value.hereIsYourPort.close();
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index 5a4fa63335581d..db251caf5f73ef 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -24,8 +24,12 @@ const { kIncomingMessage } = require('_http_common');
 const { kServerResponse } = require('_http_server');
 const { StreamWrap } = require('_stream_wrap');
 
-const { defaultTriggerAsyncIdScope } = require('internal/async_hooks');
-const { async_id_symbol } = require('internal/async_hooks').symbols;
+const {
+  defaultTriggerAsyncIdScope,
+  symbols: {
+    async_id_symbol,
+  },
+} = require('internal/async_hooks');
 const { internalBinding } = require('internal/bootstrap/loaders');
 const {
   codes: {
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 7785865d6573f9..618f1adac8deb7 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -14,13 +14,14 @@ const fs = require('fs');
 const { _makeLong } = require('path');
 const { SafeMap } = require('internal/safe_globals');
 const { URL } = require('url');
-const util = require('util');
-const debug = util.debuglog('esm');
-const readFileAsync = util.promisify(fs.readFile);
+const { debuglog, promisify } = require('util');
+const readFileAsync = promisify(fs.readFile);
 const readFileSync = fs.readFileSync;
 const StringReplace = Function.call.bind(String.prototype.replace);
 const JsonParse = JSON.parse;
 
+const debug = debuglog('esm');
+
 const translators = new SafeMap();
 module.exports = translators;
 
diff --git a/test/.eslintrc.yaml b/test/.eslintrc.yaml
index c57d7505c984ff..25026fec5a103a 100644
--- a/test/.eslintrc.yaml
+++ b/test/.eslintrc.yaml
@@ -18,6 +18,7 @@ rules:
   node-core/number-isnan: error
   ## common module is mandatory in tests
   node-core/required-modules: [error, common]
+  node-core/no-duplicate-requires: off
 
   no-restricted-syntax:
     # Config copied from .eslintrc.js
diff --git a/test/parallel/test-eslint-duplicate-requires.js b/test/parallel/test-eslint-duplicate-requires.js
new file mode 100644
index 00000000000000..c7edaeed2b6b6e
--- /dev/null
+++ b/test/parallel/test-eslint-duplicate-requires.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfEslintMissing();
+
+const { RuleTester } = require('../../tools/node_modules/eslint');
+const rule = require('../../tools/eslint-rules/no-duplicate-requires');
+
+new RuleTester().run('no-duplicate-requires', rule, {
+  valid: [
+    {
+      code: 'require("a"); require("b"); (function() { require("a"); });',
+    },
+    {
+      code: 'require(a); require(a);',
+    },
+  ],
+  invalid: [
+    {
+      code: 'require("a"); require("a");',
+      errors: [{ message: '\'a\' require is duplicated.' }],
+    },
+  ],
+});
diff --git a/tools/eslint-rules/no-duplicate-requires.js b/tools/eslint-rules/no-duplicate-requires.js
new file mode 100644
index 00000000000000..595c22360112ca
--- /dev/null
+++ b/tools/eslint-rules/no-duplicate-requires.js
@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Ensure modules are not required twice at top level of a module
+ * @author devsnek
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+
+function isString(node) {
+  return node && node.type === 'Literal' && typeof node.value === 'string';
+}
+
+function isRequireCall(node) {
+  return node.callee.type === 'Identifier' && node.callee.name === 'require';
+}
+
+function isTopLevel(node) {
+  do {
+    if (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression' ||
+        node.type === 'ClassBody' ||
+        node.type === 'MethodDefinition') {
+      return false;
+    }
+  } while (node = node.parent);
+  return true;
+}
+
+module.exports = (context) => {
+  if (context.parserOptions.sourceType === 'module') {
+    return {};
+  }
+
+  function getRequiredModuleNameFromCall(node) {
+    // node has arguments and first argument is string
+    if (node.arguments.length && isString(node.arguments[0])) {
+      return node.arguments[0].value.trim();
+    }
+
+    return undefined;
+  }
+
+  const required = new Set();
+
+  const rules = {
+    CallExpression: (node) => {
+      if (isRequireCall(node) && isTopLevel(node)) {
+        const moduleName = getRequiredModuleNameFromCall(node);
+        if (moduleName === undefined) {
+          return;
+        }
+        if (required.has(moduleName)) {
+          context.report(
+            node,
+            '\'{{moduleName}}\' require is duplicated.',
+            { moduleName }
+          );
+        } else {
+          required.add(moduleName);
+        }
+      }
+    },
+  };
+
+  return rules;
+};

From c26ba082aede8b201030dfb0d34a91e01ffd1598 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 10 Jul 2018 22:30:56 -0700
Subject: [PATCH 055/116] tools: avoid global install of dmn for lint update
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When updating ESLint, use npx to run dmn rather than installing dmn
globally.

PR-URL: https://github.com/nodejs/node/pull/21744
Reviewed-By: Roman Reiss <me@silverwind.io>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 tools/update-eslint.sh | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/tools/update-eslint.sh b/tools/update-eslint.sh
index 44f43a05d31e1a..3663ecf74283c0 100755
--- a/tools/update-eslint.sh
+++ b/tools/update-eslint.sh
@@ -2,7 +2,7 @@
 
 # Shell script to update ESLint in the source tree to the latest release.
 
-# Depends on npm and node being in $PATH.
+# Depends on npm, npx, and node being in $PATH.
 
 # This script must be be in the tools directory when it runs because it uses
 # $BASH_SOURCE[0] to determine directories to work in.
@@ -19,11 +19,8 @@ cd node_modules/eslint
 npm install --no-bin-links --production --no-package-lock eslint-plugin-markdown@next
 cd ../..
 
-# Install dmn if it is not in path.
-type -P dmn || npm install -g dmn
-
 # Use dmn to remove some unneeded files.
-dmn -f clean
+npx dmn -f clean
 
 cd ..
 mv eslint-tmp/node_modules/eslint node_modules/eslint

From 3fffc7e95fa781cf57357691e78a94a6f05d0068 Mon Sep 17 00:00:00 2001
From: Shailesh Shekhawat <sshekhawat356@gmail.com>
Date: Wed, 27 Jun 2018 22:05:32 +0800
Subject: [PATCH 056/116] errors: fix undefined HTTP2 and tls errors

Includes implementation of tls, HTTP2 error with documentation.

PR-URL: https://github.com/nodejs/node/pull/21564
Refs: https://github.com/nodejs/node/issues/21440
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
---
 doc/api/errors.md      | 10 ++++++++++
 lib/internal/errors.js |  2 ++
 2 files changed, 12 insertions(+)

diff --git a/doc/api/errors.md b/doc/api/errors.md
index a122bc51e39ca6..be22aa1527727d 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1014,6 +1014,11 @@ provided.
 
 The `Http2Session` closed with a non-zero error code.
 
+<a id="ERR_HTTP2_SETTINGS_CANCEL"></a>
+### ERR_HTTP2_SETTINGS_CANCEL
+
+The `Http2Session` settings canceled.
+
 <a id="ERR_HTTP2_SOCKET_BOUND"></a>
 ### ERR_HTTP2_SOCKET_BOUND
 
@@ -1629,6 +1634,11 @@ recommended to use 2048 bits or larger for stronger security.
 A TLS/SSL handshake timed out. In this case, the server must also abort the
 connection.
 
+<a id="ERR_TLS_RENEGOTIATE"></a>
+### ERR_TLS_RENEGOTIATE
+
+An attempt to renegotiate the TLS session failed.
+
 <a id="ERR_TLS_RENEGOTIATION_DISABLED"></a>
 ### ERR_TLS_RENEGOTIATION_DISABLED
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index c3f1c374011b05..aef05489b48c74 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -585,6 +585,7 @@ E('ERR_HTTP2_SEND_FILE', 'Directories cannot be sent', Error);
 E('ERR_HTTP2_SEND_FILE_NOSEEK',
   'Offset or length can only be specified for regular files', Error);
 E('ERR_HTTP2_SESSION_ERROR', 'Session closed with error code %s', Error);
+E('ERR_HTTP2_SETTINGS_CANCEL', 'HTTP2 session settings canceled', Error);
 E('ERR_HTTP2_SOCKET_BOUND',
   'The socket is already bound to an Http2Session', Error);
 E('ERR_HTTP2_STATUS_101',
@@ -812,6 +813,7 @@ E('ERR_TLS_CERT_ALTNAME_INVALID',
   'Hostname/IP does not match certificate\'s altnames: %s', Error);
 E('ERR_TLS_DH_PARAM_SIZE', 'DH parameter size %s is less than 2048', Error);
 E('ERR_TLS_HANDSHAKE_TIMEOUT', 'TLS handshake timeout', Error);
+E('ERR_TLS_RENEGOTIATE', 'Attempt to renegotiate TLS session failed', Error);
 E('ERR_TLS_RENEGOTIATION_DISABLED',
   'TLS session renegotiation disabled for this socket', Error);
 

From 3d93273bf73a767ef8b64bf68ca73c5aa58b7de4 Mon Sep 17 00:00:00 2001
From: XadillaX <i@2333.moe>
Date: Wed, 30 May 2018 18:21:20 +0800
Subject: [PATCH 057/116] doc: add OS X to instead of only macOS

The last OS X version is 10.11 El Captian, and the first macOS version
is 10.12 Sierra. So >= 10.8 < 10.10 is called OS X and >= 10.10 is
called OS X or macOS.

Refs: https://en.wikipedia.org/wiki/MacOS#Release_history

PR-URL: https://github.com/nodejs/node/pull/21033
Reviewed-By: Roman Reiss <me@silverwind.io>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Yorkie Liu <yorkiefixer@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 BUILDING.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/BUILDING.md b/BUILDING.md
index 48c287a319273e..a37ecb701ef04e 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -41,14 +41,14 @@ platforms in production.
 |--------------|--------------|----------------------------------|----------------------|------------------|
 | GNU/Linux    | Tier 1       | kernel >= 2.6.32, glibc >= 2.12  | x64, arm             |                  |
 | GNU/Linux    | Tier 1       | kernel >= 3.10, glibc >= 2.17    | arm64                |                  |
-| macOS        | Tier 1       | >= 10.10                         | x64                  |                  |
+| macOS/OS X   | Tier 1       | >= 10.10                         | x64                  |                  |
 | Windows      | Tier 1       | >= Windows 7/2008 R2/2012 R2     | x86, x64             | vs2017           |
 | SmartOS      | Tier 2       | >= 15 < 16.4                     | x86, x64             | see note1        |
 | FreeBSD      | Tier 2       | >= 10                            | x64                  |                  |
 | GNU/Linux    | Tier 2       | kernel >= 3.13.0, glibc >= 2.19  | ppc64le >=power8     |                  |
 | AIX          | Tier 2       | >= 7.1 TL04                      | ppc64be >=power7     |                  |
 | GNU/Linux    | Tier 2       | kernel >= 3.10, glibc >= 2.17    | s390x                |                  |
-| macOS        | Experimental | >= 10.8 < 10.10                  | x64                  | no test coverage |
+| OS X         | Experimental | >= 10.8 < 10.10                  | x64                  | no test coverage |
 | GNU/Linux    | Experimental | kernel >= 2.6.32, glibc >= 2.12  | x86                  | limited CI       |
 | Linux (musl) | Experimental | musl >= 1.0                      | x64                  |                  |
 
@@ -408,7 +408,7 @@ This version of Node.js does not support FIPS.
 It is possible to specify one or more JavaScript text files to be bundled in
 the binary as builtin modules when building Node.js.
 
-### Unix / macOS
+### Unix/macOS
 
 This command will make `/root/myModule.js` available via
 `require('/root/myModule')` and `./myModule2.js` available via

From bba500d0eac378662bb7dbd4ef1ac4232cedca66 Mon Sep 17 00:00:00 2001
From: killagu <killa123@126.com>
Date: Fri, 8 Jun 2018 12:42:27 +0800
Subject: [PATCH 058/116] http: fix request with option timeout and agent

When request with both timeout and agent, timeout not
work. This patch will fix it, socket timeout will set
to request timeout before socket is connected, and
socket timeout will reset to agent timeout after
response end.

Fixes: https://github.com/nodejs/node/issues/21185

PR-URL: https://github.com/nodejs/node/pull/21204
Reviewed-By: Khaidi Chu <i@2333.moe>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
---
 doc/api/http.md                               |  2 +
 lib/_http_agent.js                            | 33 +++++++--
 lib/_http_client.js                           | 74 ++++++++++---------
 lib/net.js                                    |  1 +
 test/parallel/test-http-client-set-timeout.js | 46 ++++++++++++
 ...t-http-client-timeout-option-with-agent.js | 55 ++++++++++++++
 6 files changed, 169 insertions(+), 42 deletions(-)
 create mode 100644 test/parallel/test-http-client-set-timeout.js
 create mode 100644 test/parallel/test-http-client-timeout-option-with-agent.js

diff --git a/doc/api/http.md b/doc/api/http.md
index fe1c387654e9c8..578f21c45e30ca 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -126,6 +126,8 @@ added: v0.3.4
   * `maxFreeSockets` {number} Maximum number of sockets to leave open
     in a free state. Only relevant if `keepAlive` is set to `true`.
     **Default:** `256`.
+  * `timeout` {number} Socket timeout in milliseconds.
+    This will set the timeout after the socket is connected.
 
 The default [`http.globalAgent`][] that is used by [`http.request()`][] has all
 of these values set to their respective defaults.
diff --git a/lib/_http_agent.js b/lib/_http_agent.js
index 67f3d667b28169..1a2920cf098298 100644
--- a/lib/_http_agent.js
+++ b/lib/_http_agent.js
@@ -66,7 +66,8 @@ function Agent(options) {
 
     if (socket.writable &&
         this.requests[name] && this.requests[name].length) {
-      this.requests[name].shift().onSocket(socket);
+      const req = this.requests[name].shift();
+      setRequestSocket(this, req, socket);
       if (this.requests[name].length === 0) {
         // don't leak
         delete this.requests[name];
@@ -176,12 +177,12 @@ Agent.prototype.addRequest = function addRequest(req, options, port/* legacy */,
       delete this.freeSockets[name];
 
     this.reuseSocket(socket, req);
-    req.onSocket(socket);
+    setRequestSocket(this, req, socket);
     this.sockets[name].push(socket);
   } else if (sockLen < this.maxSockets) {
     debug('call onSocket', sockLen, freeLen);
     // If we are under maxSockets create a new one.
-    this.createSocket(req, options, handleSocketCreation(req, true));
+    this.createSocket(req, options, handleSocketCreation(this, req, true));
   } else {
     debug('wait for socket');
     // We are over limit so we'll add it to the queue.
@@ -305,9 +306,10 @@ Agent.prototype.removeSocket = function removeSocket(s, options) {
 
   if (this.requests[name] && this.requests[name].length) {
     debug('removeSocket, have a request, make a socket');
-    var req = this.requests[name][0];
+    const req = this.requests[name][0];
     // If we have pending requests and a socket gets closed make a new one
-    this.createSocket(req, options, handleSocketCreation(req, false));
+    const socketCreationHandler = handleSocketCreation(this, req, false);
+    this.createSocket(req, options, socketCreationHandler);
   }
 };
 
@@ -337,19 +339,36 @@ Agent.prototype.destroy = function destroy() {
   }
 };
 
-function handleSocketCreation(request, informRequest) {
+function handleSocketCreation(agent, request, informRequest) {
   return function handleSocketCreation_Inner(err, socket) {
     if (err) {
       process.nextTick(emitErrorNT, request, err);
       return;
     }
     if (informRequest)
-      request.onSocket(socket);
+      setRequestSocket(agent, request, socket);
     else
       socket.emit('free');
   };
 }
 
+function setRequestSocket(agent, req, socket) {
+  req.onSocket(socket);
+  const agentTimeout = agent.options.timeout || 0;
+  if (req.timeout === undefined || req.timeout === agentTimeout) {
+    return;
+  }
+  socket.setTimeout(req.timeout);
+  // reset timeout after response end
+  req.once('response', (res) => {
+    res.once('end', () => {
+      if (socket.timeout !== agentTimeout) {
+        socket.setTimeout(agentTimeout);
+      }
+    });
+  });
+}
+
 function emitErrorNT(emitter, err) {
   emitter.emit('error', err);
 }
diff --git a/lib/_http_client.js b/lib/_http_client.js
index d3616eb6b5e7f9..0612f5822a303f 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -639,18 +639,35 @@ function tickOnSocket(req, socket) {
   socket.on('end', socketOnEnd);
   socket.on('close', socketCloseListener);
 
-  if (req.timeout) {
-    const emitRequestTimeout = () => req.emit('timeout');
-    socket.once('timeout', emitRequestTimeout);
-    req.once('response', (res) => {
-      res.once('end', () => {
-        socket.removeListener('timeout', emitRequestTimeout);
-      });
-    });
+  if (req.timeout !== undefined) {
+    listenSocketTimeout(req);
   }
   req.emit('socket', socket);
 }
 
+function listenSocketTimeout(req) {
+  if (req.timeoutCb) {
+    return;
+  }
+  const emitRequestTimeout = () => req.emit('timeout');
+  // Set timeoutCb so it will get cleaned up on request end.
+  req.timeoutCb = emitRequestTimeout;
+  // Delegate socket timeout event.
+  if (req.socket) {
+    req.socket.once('timeout', emitRequestTimeout);
+  } else {
+    req.on('socket', (socket) => {
+      socket.once('timeout', emitRequestTimeout);
+    });
+  }
+  // Remove socket timeout listener after response end.
+  req.once('response', (res) => {
+    res.once('end', () => {
+      req.socket.removeListener('timeout', emitRequestTimeout);
+    });
+  });
+}
+
 ClientRequest.prototype.onSocket = function onSocket(socket) {
   process.nextTick(onSocketNT, this, socket);
 };
@@ -700,42 +717,29 @@ function _deferToConnect(method, arguments_, cb) {
 }
 
 ClientRequest.prototype.setTimeout = function setTimeout(msecs, callback) {
+  listenSocketTimeout(this);
   msecs = validateTimerDuration(msecs);
   if (callback) this.once('timeout', callback);
 
-  const emitTimeout = () => this.emit('timeout');
-
-  if (this.socket && this.socket.writable) {
-    if (this.timeoutCb)
-      this.socket.setTimeout(0, this.timeoutCb);
-    this.timeoutCb = emitTimeout;
-    this.socket.setTimeout(msecs, emitTimeout);
-    return this;
-  }
-
-  // Set timeoutCb so that it'll get cleaned up on request end
-  this.timeoutCb = emitTimeout;
   if (this.socket) {
-    var sock = this.socket;
-    this.socket.once('connect', function() {
-      sock.setTimeout(msecs, emitTimeout);
-    });
-    return this;
+    setSocketTimeout(this.socket, msecs);
+  } else {
+    this.once('socket', (sock) => setSocketTimeout(sock, msecs));
   }
 
-  this.once('socket', function(sock) {
-    if (sock.connecting) {
-      sock.once('connect', function() {
-        sock.setTimeout(msecs, emitTimeout);
-      });
-    } else {
-      sock.setTimeout(msecs, emitTimeout);
-    }
-  });
-
   return this;
 };
 
+function setSocketTimeout(sock, msecs) {
+  if (sock.connecting) {
+    sock.once('connect', function() {
+      sock.setTimeout(msecs);
+    });
+  } else {
+    sock.setTimeout(msecs);
+  }
+}
+
 ClientRequest.prototype.setNoDelay = function setNoDelay(noDelay) {
   this._deferToConnect('setNoDelay', [noDelay]);
 };
diff --git a/lib/net.js b/lib/net.js
index 2393539737910a..889f28b0aa7042 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -408,6 +408,7 @@ function writeAfterFIN(chunk, encoding, cb) {
 }
 
 Socket.prototype.setTimeout = function(msecs, callback) {
+  this.timeout = msecs;
   // Type checking identical to timers.enroll()
   msecs = validateTimerDuration(msecs);
 
diff --git a/test/parallel/test-http-client-set-timeout.js b/test/parallel/test-http-client-set-timeout.js
new file mode 100644
index 00000000000000..51284b42765493
--- /dev/null
+++ b/test/parallel/test-http-client-set-timeout.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+
+// Test that `req.setTimeout` will fired exactly once.
+
+const assert = require('assert');
+const http = require('http');
+
+const HTTP_CLIENT_TIMEOUT = 2000;
+
+const options = {
+  method: 'GET',
+  port: undefined,
+  host: '127.0.0.1',
+  path: '/',
+  timeout: HTTP_CLIENT_TIMEOUT,
+};
+
+const server = http.createServer(() => {
+  // Never respond.
+});
+
+server.listen(0, options.host, function() {
+  doRequest();
+});
+
+function doRequest() {
+  options.port = server.address().port;
+  const req = http.request(options);
+  req.setTimeout(HTTP_CLIENT_TIMEOUT / 2);
+  req.on('error', () => {
+    // This space is intentionally left blank.
+  });
+  req.on('close', common.mustCall(() => server.close()));
+
+  let timeout_events = 0;
+  req.on('timeout', common.mustCall(() => {
+    timeout_events += 1;
+  }));
+  req.end();
+
+  setTimeout(function() {
+    req.destroy();
+    assert.strictEqual(timeout_events, 1);
+  }, common.platformTimeout(HTTP_CLIENT_TIMEOUT));
+}
diff --git a/test/parallel/test-http-client-timeout-option-with-agent.js b/test/parallel/test-http-client-timeout-option-with-agent.js
new file mode 100644
index 00000000000000..a7f750a42e557b
--- /dev/null
+++ b/test/parallel/test-http-client-timeout-option-with-agent.js
@@ -0,0 +1,55 @@
+'use strict';
+const common = require('../common');
+
+// Test that when http request uses both timeout and agent,
+// timeout will work as expected.
+
+const assert = require('assert');
+const http = require('http');
+
+const HTTP_AGENT_TIMEOUT = 1000;
+const HTTP_CLIENT_TIMEOUT = 3000;
+
+const agent = new http.Agent({ timeout: HTTP_AGENT_TIMEOUT });
+const options = {
+  method: 'GET',
+  port: undefined,
+  host: '127.0.0.1',
+  path: '/',
+  timeout: HTTP_CLIENT_TIMEOUT,
+  agent,
+};
+
+const server = http.createServer(() => {
+  // Never respond.
+});
+
+server.listen(0, options.host, function() {
+  doRequest();
+});
+
+function doRequest() {
+  options.port = server.address().port;
+  const req = http.request(options);
+  const start = Date.now();
+  req.on('error', () => {
+    // This space is intentionally left blank.
+  });
+  req.on('close', common.mustCall(() => server.close()));
+
+  let timeout_events = 0;
+  req.on('timeout', common.mustCall(() => {
+    timeout_events += 1;
+    const duration = Date.now() - start;
+    // The timeout event cannot be precisely timed. It will delay
+    // some number of milliseconds, so test it in second units.
+    assert.strictEqual(duration / 1000 | 0, HTTP_CLIENT_TIMEOUT / 1000);
+  }));
+  req.end();
+
+  setTimeout(function() {
+    req.destroy();
+    assert.strictEqual(timeout_events, 1);
+    // Ensure the `timeout` event fired only once.
+  }, common.platformTimeout(HTTP_CLIENT_TIMEOUT * 2));
+}

From 4b613d39765eb0529fc6b01b172d7e7e70beeaa1 Mon Sep 17 00:00:00 2001
From: Sam Ruby <rubys@intertwingly.net>
Date: Fri, 29 Jun 2018 12:49:36 -0400
Subject: [PATCH 059/116] repl: make own properties shadow prototype properties

Previously, the code displayed properties backwards (e.g., showing
prototype properties before own properties).  It also did uniqueness
checks during this processing, so these checks were done backwards.

After this change, the properties continue to be displayed backwards,
but the uniqueness checks are done in the proper order.

See also: https://github.com/nodejs/node/issues/21586 which was
discovered during the testing of this fix.

Fixes: https://github.com/nodejs/node/issues/15199
PR-URL: https://github.com/nodejs/node/pull/21588
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 lib/repl.js                             | 12 ++++++------
 test/parallel/test-repl-tab-complete.js | 19 ++++++++++++++++++-
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/lib/repl.js b/lib/repl.js
index 6345c742f68f33..92c90de7bb1646 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -1229,20 +1229,20 @@ function complete(line, callback) {
       // Completion group 0 is the "closest"
       // (least far up the inheritance chain)
       // so we put its completions last: to be closest in the REPL.
-      for (i = completionGroups.length - 1; i >= 0; i--) {
+      for (i = 0; i < completionGroups.length; i++) {
         group = completionGroups[i];
         group.sort();
-        for (var j = 0; j < group.length; j++) {
+        for (var j = group.length - 1; j >= 0; j--) {
           c = group[j];
           if (!hasOwnProperty(uniq, c)) {
-            completions.push(c);
+            completions.unshift(c);
             uniq[c] = true;
           }
         }
-        completions.push(''); // Separator btwn groups
+        completions.unshift(''); // Separator btwn groups
       }
-      while (completions.length && completions[completions.length - 1] === '') {
-        completions.pop();
+      while (completions.length && completions[0] === '') {
+        completions.shift();
       }
     }
 
diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
index 0e6c4bb654910e..9d6ecf4e284811 100644
--- a/test/parallel/test-repl-tab-complete.js
+++ b/test/parallel/test-repl-tab-complete.js
@@ -149,7 +149,10 @@ putIn.run([
   ' one:1',
   '};'
 ]);
-testMe.complete('inner.o', getNoResultsFunction());
+// See: https://github.com/nodejs/node/issues/21586
+// testMe.complete('inner.o', getNoResultsFunction());
+testMe.complete('inner.o', common.mustCall(function(error, data) {
+}));
 
 putIn.run(['.clear']);
 
@@ -206,6 +209,20 @@ testMe.complete('toSt', common.mustCall(function(error, data) {
   assert.deepStrictEqual(data, [['toString'], 'toSt']);
 }));
 
+// own properties should shadow properties on the prototype
+putIn.run(['.clear']);
+putIn.run([
+  'var x = Object.create(null);',
+  'x.a = 1;',
+  'x.b = 2;',
+  'var y = Object.create(x);',
+  'y.a = 3;',
+  'y.c = 4;'
+]);
+testMe.complete('y.', common.mustCall(function(error, data) {
+  assert.deepStrictEqual(data, [['y.b', '', 'y.a', 'y.c'], 'y.']);
+}));
+
 // Tab complete provides built in libs for require()
 putIn.run(['.clear']);
 

From c02fb88936acc3fbb654464d0edc25dcea2f286a Mon Sep 17 00:00:00 2001
From: Octavian Soldea <octavian.soldea@intel.com>
Date: Thu, 5 Jul 2018 11:19:22 -0700
Subject: [PATCH 060/116] build: enabling lto at configure

This modification allows for compiling with link time optimization (lto)
using the flag --enable-lto.

Refs: https://github.com/nodejs/node/issues/7400

PR-URL: https://github.com/nodejs/node/pull/21677
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 common.gypi | 11 +++++++++++
 configure   | 24 ++++++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/common.gypi b/common.gypi
index 65eb7caf575498..9d74b46a8d5c70 100644
--- a/common.gypi
+++ b/common.gypi
@@ -176,6 +176,17 @@
           ['OS!="mac" and OS!="win"', {
             'cflags': [ '-fno-omit-frame-pointer' ],
           }],
+          ['OS=="linux"', {
+            'variables': {
+              'lto': ' -flto=4 -fuse-linker-plugin -ffat-lto-objects ',
+            },
+            'conditions': [
+              ['enable_lto=="true"', {
+                'cflags': ['<(lto)'],
+                'ldflags': ['<(lto)'],
+              },],
+            ],
+          },],
           ['OS == "android"', {
             'cflags': [ '-fPIE' ],
             'ldflags': [ '-fPIE', '-pie' ]
diff --git a/configure b/configure
index 094d8e09f745d9..068fb8a76999a1 100755
--- a/configure
+++ b/configure
@@ -157,6 +157,11 @@ parser.add_option("--enable-vtune-profiling",
          "JavaScript code executed in nodejs. This feature is only available "
          "for x32, x86, and x64 architectures.")
 
+parser.add_option("--enable-lto",
+    action="store_true",
+    dest="enable_lto",
+    help="Enable compiling with lto of a binary. This feature is only available "
+         "on linux with gcc and g++.")
 
 parser.add_option("--link-module",
     action="append",
@@ -932,6 +937,25 @@ def configure_node(o):
   else:
     o['variables']['node_enable_v8_vtunejit'] = 'false'
 
+  if flavor != 'linux' and (options.enable_lto):
+    raise Exception(
+      'The lto option is supported only on linux.')
+
+  if flavor == 'linux':
+    if options.enable_lto:
+      version_checked = (5, 4, 1)
+      for compiler in [(CC, 'c'), (CXX, 'c++')]:
+        ok, is_clang, clang_version, compiler_version = \
+          try_check_compiler(compiler[0], compiler[1])
+        compiler_version_num = tuple(map(int, compiler_version))
+        if is_clang or compiler_version_num < version_checked:
+          version_checked_str = ".".join(map(str, version_checked))
+          raise Exception(
+            'The option --enable-lto is supported for gcc and gxx %s'
+            ' or newer only.' % (version_checked_str))
+
+  o['variables']['enable_lto'] = b(options.enable_lto)
+
   if flavor in ('solaris', 'mac', 'linux', 'freebsd'):
     use_dtrace = not options.without_dtrace
     # Don't enable by default on linux and freebsd

From f46536be23b5b31222fe33ae85bab0f92a28bb47 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 15:07:23 +0200
Subject: [PATCH 061/116] test: fix timeouts when running worker tests with
 `--worker`

These tests have been added after the original workers PR and
time out when run inside a worker by themselves.
This is needed for enabling `--worker` tests in our regular CI.

Refs: https://github.com/nodejs/build/issues/1318

PR-URL: https://github.com/nodejs/node/pull/21791
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 test/parallel/test-worker-exit-code.js | 6 ++++--
 test/parallel/test-worker-onmessage.js | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
index bb47e1cece7a62..b621389b49ca6b 100644
--- a/test/parallel/test-worker-exit-code.js
+++ b/test/parallel/test-worker-exit-code.js
@@ -7,9 +7,11 @@ const common = require('../common');
 
 const assert = require('assert');
 const worker = require('worker_threads');
-const { Worker, isMainThread, parentPort } = worker;
+const { Worker, parentPort } = worker;
 
-if (isMainThread) {
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
   parent();
 } else {
   if (!parentPort) {
diff --git a/test/parallel/test-worker-onmessage.js b/test/parallel/test-worker-onmessage.js
index 895536c15038be..2ae3d90f852ba9 100644
--- a/test/parallel/test-worker-onmessage.js
+++ b/test/parallel/test-worker-onmessage.js
@@ -2,9 +2,11 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
-const { Worker, isMainThread, parentPort } = require('worker_threads');
+const { Worker, parentPort } = require('worker_threads');
 
-if (isMainThread) {
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
   const w = new Worker(__filename);
   w.on('message', common.mustCall((message) => {
     assert.strictEqual(message, 4);

From 712809eb1b29fbfd304c942fe0b4f7acf682dc6c Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sun, 10 Jun 2018 16:40:13 +0200
Subject: [PATCH 062/116] src: enable more detailed memory tracking

This will enable more detailed heap snapshots based on
a newer V8 API.

This commit itself is not tied to that API and could
be backported.

PR-URL: https://github.com/nodejs/node/pull/21742
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 node.gyp                                     |   2 +
 src/async_wrap.cc                            |  21 +++-
 src/async_wrap.h                             |   1 -
 src/base_object-inl.h                        |  10 +-
 src/base_object.h                            |  13 ++-
 src/cares_wrap.cc                            |  77 +++++++++----
 src/connect_wrap.h                           |   4 +-
 src/env.cc                                   |  14 +++
 src/fs_event_wrap.cc                         |   5 +-
 src/inspector_js_api.cc                      |   6 +-
 src/js_stream.h                              |   4 +-
 src/memory_tracker-inl.h                     | 107 +++++++++++++++++++
 src/memory_tracker.h                         |  87 +++++++++++++++
 src/module_wrap.h                            |   6 ++
 src/node_contextify.cc                       |   4 +
 src/node_contextify.h                        |   1 +
 src/node_crypto.cc                           |   2 +
 src/node_crypto.h                            |  28 +++++
 src/node_crypto_bio.h                        |   7 +-
 src/node_file.h                              |  27 ++++-
 src/node_http2.cc                            |  27 +++--
 src/node_http2.h                             |  37 +++++--
 src/node_http_parser.cc                      |   5 +-
 src/node_i18n.cc                             |   4 +
 src/node_messaging.cc                        |  22 ++--
 src/node_messaging.h                         |  13 ++-
 src/node_serdes.cc                           |  10 ++
 src/node_stat_watcher.h                      |   4 +-
 src/node_trace_events.cc                     |   5 +
 src/node_worker.cc                           |   4 -
 src/node_worker.h                            |   9 +-
 src/node_zlib.cc                             |   7 +-
 src/pipe_wrap.h                              |   4 +-
 src/process_wrap.cc                          |   4 +-
 src/sharedarraybuffer_metadata.cc            |   4 +
 src/signal_wrap.cc                           |   4 +-
 src/stream_base.h                            |  11 +-
 src/stream_pipe.h                            |   4 +-
 src/tcp_wrap.h                               |   4 +-
 src/timer_wrap.cc                            |   4 +-
 src/tls_wrap.cc                              |   9 ++
 src/tls_wrap.h                               |   2 +-
 src/tty_wrap.h                               |   4 +-
 src/udp_wrap.cc                              |   6 +-
 src/udp_wrap.h                               |   4 +-
 test/cctest/test_node_postmortem_metadata.cc |  20 +++-
 46 files changed, 566 insertions(+), 91 deletions(-)
 create mode 100644 src/memory_tracker-inl.h
 create mode 100644 src/memory_tracker.h

diff --git a/node.gyp b/node.gyp
index 35a81437afdfcf..ae254278198edf 100644
--- a/node.gyp
+++ b/node.gyp
@@ -420,6 +420,8 @@
         'src/node_revert.h',
         'src/node_i18n.h',
         'src/node_worker.h',
+        'src/memory_tracker.h',
+        'src/memory_tracker-inl.h',
         'src/pipe_wrap.h',
         'src/tty_wrap.h',
         'src/tcp_wrap.h',
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index 89e82b9ce364b6..e98dca3c56651b 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -76,14 +76,22 @@ class RetainedAsyncInfo: public RetainedObjectInfo {
  private:
   const char* label_;
   const AsyncWrap* wrap_;
-  const int length_;
+  const size_t length_;
 };
 
 
+static int OwnMemory(AsyncWrap* async_wrap) {
+  MemoryTracker tracker;
+  tracker.set_track_only_self(true);
+  tracker.Track(async_wrap);
+  return tracker.accumulated_size();
+}
+
+
 RetainedAsyncInfo::RetainedAsyncInfo(uint16_t class_id, AsyncWrap* wrap)
     : label_(provider_names[class_id - NODE_ASYNC_ID_OFFSET]),
       wrap_(wrap),
-      length_(wrap->self_size()) {
+      length_(OwnMemory(wrap)) {
 }
 
 
@@ -147,7 +155,9 @@ struct AsyncWrapObject : public AsyncWrap {
   inline AsyncWrapObject(Environment* env, Local<Object> object,
                          ProviderType type) : AsyncWrap(env, object, type) {}
 
-  inline size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 };
 
 
@@ -252,7 +262,10 @@ class PromiseWrap : public AsyncWrap {
       : AsyncWrap(env, object, PROVIDER_PROMISE, -1, silent) {
     MakeWeak();
   }
-  size_t self_size() const override { return sizeof(*this); }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
   static constexpr int kPromiseField = 1;
   static constexpr int kIsChainedPromiseField = 2;
diff --git a/src/async_wrap.h b/src/async_wrap.h
index 82c57910925be9..c1d90f8fad0541 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -174,7 +174,6 @@ class AsyncWrap : public BaseObject {
       int argc,
       v8::Local<v8::Value>* argv);
 
-  virtual size_t self_size() const = 0;
   virtual std::string diagnostic_name() const;
 
   static void WeakCallback(const v8::WeakCallbackInfo<DestroyParam> &info);
diff --git a/src/base_object-inl.h b/src/base_object-inl.h
index 06a29223973c5d..d067a807cb8e14 100644
--- a/src/base_object-inl.h
+++ b/src/base_object-inl.h
@@ -61,11 +61,11 @@ Persistent<v8::Object>& BaseObject::persistent() {
 }
 
 
-v8::Local<v8::Object> BaseObject::object() {
+v8::Local<v8::Object> BaseObject::object() const {
   return PersistentToLocal(env_->isolate(), persistent_handle_);
 }
 
-v8::Local<v8::Object> BaseObject::object(v8::Isolate* isolate) {
+v8::Local<v8::Object> BaseObject::object(v8::Isolate* isolate) const {
   v8::Local<v8::Object> handle = object();
 #ifdef DEBUG
   CHECK_EQ(handle->CreationContext()->GetIsolate(), isolate);
@@ -91,12 +91,6 @@ T* BaseObject::FromJSObject(v8::Local<v8::Object> object) {
 }
 
 
-void BaseObject::DeleteMe(void* data) {
-  BaseObject* self = static_cast<BaseObject*>(data);
-  delete self;
-}
-
-
 void BaseObject::MakeWeak() {
   persistent_handle_.SetWeak(
       this,
diff --git a/src/base_object.h b/src/base_object.h
index 38291d598feb1c..e0f3f27950e7d0 100644
--- a/src/base_object.h
+++ b/src/base_object.h
@@ -25,6 +25,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "node_persistent.h"
+#include "memory_tracker-inl.h"
 #include "v8.h"
 #include <type_traits>  // std::remove_reference
 
@@ -32,7 +33,7 @@ namespace node {
 
 class Environment;
 
-class BaseObject {
+class BaseObject : public MemoryRetainer {
  public:
   // Associates this object with `object`. It uses the 0th internal field for
   // that, and in particular aborts if there is no such field.
@@ -41,11 +42,11 @@ class BaseObject {
 
   // Returns the wrapped object.  Returns an empty handle when
   // persistent.IsEmpty() is true.
-  inline v8::Local<v8::Object> object();
+  inline v8::Local<v8::Object> object() const;
 
   // Same as the above, except it additionally verifies that this object
   // is associated with the passed Isolate in debug mode.
-  inline v8::Local<v8::Object> object(v8::Isolate* isolate);
+  inline v8::Local<v8::Object> object(v8::Isolate* isolate) const;
 
   inline Persistent<v8::Object>& persistent();
 
@@ -75,7 +76,9 @@ class BaseObject {
  private:
   BaseObject();
 
-  static inline void DeleteMe(void* data);
+  v8::Local<v8::Object> WrappedObject() const override;
+  bool IsRootNode() const override;
+  static void DeleteMe(void* data);
 
   // persistent_handle_ needs to be at a fixed offset from the start of the
   // class because it is used by src/node_postmortem_metadata.cc to calculate
@@ -83,6 +86,8 @@ class BaseObject {
   // position of members in memory are predictable. For more information please
   // refer to `doc/guides/node-postmortem-support.md`
   friend int GenDebugSymbols();
+  friend class Environment;
+
   Persistent<v8::Object> persistent_handle_;
   Environment* env_;
 };
diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 05ef2b7e12090e..af564df8053955 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -121,10 +121,12 @@ inline const char* ToErrorCodeString(int status) {
 
 class ChannelWrap;
 
-struct node_ares_task {
+struct node_ares_task : public MemoryRetainer {
   ChannelWrap* channel;
   ares_socket_t sock;
   uv_poll_t poll_watcher;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
 };
 
 struct TaskHash {
@@ -167,7 +169,12 @@ class ChannelWrap : public AsyncWrap {
   inline int active_query_count() { return active_query_count_; }
   inline node_ares_task_list* task_list() { return &task_list_; }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    if (timer_handle_ != nullptr)
+      tracker->TrackFieldWithSize("timer handle", sizeof(*timer_handle_));
+    tracker->TrackField("task list", task_list_);
+  }
 
   static void AresTimeout(uv_timer_t* handle);
 
@@ -181,6 +188,11 @@ class ChannelWrap : public AsyncWrap {
   node_ares_task_list task_list_;
 };
 
+void node_ares_task::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackThis(this);
+  tracker->TrackField("channel", channel);
+}
+
 ChannelWrap::ChannelWrap(Environment* env,
                          Local<Object> object)
   : AsyncWrap(env, object, PROVIDER_DNSCHANNEL),
@@ -209,7 +221,10 @@ class GetAddrInfoReqWrap : public ReqWrap<uv_getaddrinfo_t> {
                      Local<Object> req_wrap_obj,
                      bool verbatim);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
   bool verbatim() const { return verbatim_; }
 
  private:
@@ -228,7 +243,9 @@ class GetNameInfoReqWrap : public ReqWrap<uv_getnameinfo_t> {
  public:
   GetNameInfoReqWrap(Environment* env, Local<Object> req_wrap_obj);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 };
 
 GetNameInfoReqWrap::GetNameInfoReqWrap(Environment* env,
@@ -270,13 +287,13 @@ void ares_poll_cb(uv_poll_t* watcher, int status, int events) {
 
 void ares_poll_close_cb(uv_poll_t* watcher) {
   node_ares_task* task = ContainerOf(&node_ares_task::poll_watcher, watcher);
-  free(task);
+  delete task;
 }
 
 
 /* Allocates and returns a new node_ares_task */
 node_ares_task* ares_task_create(ChannelWrap* channel, ares_socket_t sock) {
-  auto task = node::UncheckedMalloc<node_ares_task>(1);
+  auto task = new node_ares_task();
 
   if (task == nullptr) {
     /* Out of memory. */
@@ -1172,7 +1189,9 @@ class QueryAnyWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1349,7 +1368,9 @@ class QueryAWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1393,7 +1414,9 @@ class QueryAaaaWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1437,7 +1460,9 @@ class QueryCnameWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1468,7 +1493,9 @@ class QueryMxWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1499,7 +1526,9 @@ class QueryNsWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1530,7 +1559,9 @@ class QueryTxtWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1560,7 +1591,9 @@ class QuerySrvWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1589,7 +1622,9 @@ class QueryPtrWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1620,7 +1655,9 @@ class QueryNaptrWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1650,7 +1687,9 @@ class QuerySoaWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(unsigned char* buf, int len) override {
@@ -1729,7 +1768,9 @@ class GetHostByAddrWrap: public QueryWrap {
     return 0;
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   void Parse(struct hostent* host) override {
diff --git a/src/connect_wrap.h b/src/connect_wrap.h
index 80eae7f9bb8290..587e4c6b0593e5 100644
--- a/src/connect_wrap.h
+++ b/src/connect_wrap.h
@@ -16,7 +16,9 @@ class ConnectWrap : public ReqWrap<uv_connect_t> {
               v8::Local<v8::Object> req_wrap_obj,
               AsyncWrap::ProviderType provider);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 };
 
 }  // namespace node
diff --git a/src/env.cc b/src/env.cc
index 6c906e2fb19c56..006173eaaeb847 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -653,4 +653,18 @@ void Environment::stop_sub_worker_contexts() {
   }
 }
 
+// Not really any better place than env.cc at this moment.
+void BaseObject::DeleteMe(void* data) {
+  BaseObject* self = static_cast<BaseObject*>(data);
+  delete self;
+}
+
+Local<Object> BaseObject::WrappedObject() const {
+  return object();
+}
+
+bool BaseObject::IsRootNode() const {
+  return !persistent_handle_.IsWeak();
+}
+
 }  // namespace node
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index 164614ae81145f..7587ace8e3ce70 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -56,7 +56,10 @@ class FSEventWrap: public HandleWrap {
   static void New(const FunctionCallbackInfo<Value>& args);
   static void Start(const FunctionCallbackInfo<Value>& args);
   static void GetInitialized(const FunctionCallbackInfo<Value>& args);
-  size_t self_size() const override { return sizeof(*this); }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   static const encoding kDefaultEncoding = UTF8;
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 104cd93b3cd9e0..13e91f283c912a 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -103,7 +103,11 @@ class JSBindingsConnection : public AsyncWrap {
     }
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("callback", callback_);
+    tracker->TrackFieldWithSize("session", sizeof(*session_));
+  }
 
  private:
   std::unique_ptr<InspectorSession> session_;
diff --git a/src/js_stream.h b/src/js_stream.h
index b47a91a653ba7e..f3406ae83ee560 100644
--- a/src/js_stream.h
+++ b/src/js_stream.h
@@ -27,7 +27,9 @@ class JSStream : public AsyncWrap, public StreamBase {
               size_t count,
               uv_stream_t* send_handle) override;
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  protected:
   JSStream(Environment* env, v8::Local<v8::Object> obj);
diff --git a/src/memory_tracker-inl.h b/src/memory_tracker-inl.h
new file mode 100644
index 00000000000000..758223492f6e71
--- /dev/null
+++ b/src/memory_tracker-inl.h
@@ -0,0 +1,107 @@
+#ifndef SRC_MEMORY_TRACKER_INL_H_
+#define SRC_MEMORY_TRACKER_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "memory_tracker.h"
+
+namespace node {
+
+template <typename T>
+void MemoryTracker::TrackThis(const T* obj) {
+  accumulated_size_ += sizeof(T);
+}
+
+void MemoryTracker::TrackFieldWithSize(const char* name, size_t size) {
+  accumulated_size_ += size;
+}
+
+void MemoryTracker::TrackField(const char* name, const MemoryRetainer& value) {
+  TrackField(name, &value);
+}
+
+void MemoryTracker::TrackField(const char* name, const MemoryRetainer* value) {
+  if (track_only_self_ || value == nullptr || seen_.count(value) > 0) return;
+  seen_.insert(value);
+  Track(value);
+}
+
+template <typename T>
+void MemoryTracker::TrackField(const char* name,
+                               const std::unique_ptr<T>& value) {
+  TrackField(name, value.get());
+}
+
+template <typename T, typename Iterator>
+void MemoryTracker::TrackField(const char* name, const T& value) {
+  if (value.begin() == value.end()) return;
+  size_t index = 0;
+  for (Iterator it = value.begin(); it != value.end(); ++it)
+    TrackField(std::to_string(index++).c_str(), *it);
+}
+
+template <typename T>
+void MemoryTracker::TrackField(const char* name, const std::queue<T>& value) {
+  struct ContainerGetter : public std::queue<T> {
+    static const typename std::queue<T>::container_type& Get(
+        const std::queue<T>& value) {
+      return value.*&ContainerGetter::c;
+    }
+  };
+
+  const auto& container = ContainerGetter::Get(value);
+  TrackField(name, container);
+}
+
+template <typename T, typename test_for_number, typename dummy>
+void MemoryTracker::TrackField(const char* name, const T& value) {
+  // For numbers, creating new nodes is not worth the overhead.
+  TrackFieldWithSize(name, sizeof(T));
+}
+
+template <typename T, typename U>
+void MemoryTracker::TrackField(const char* name, const std::pair<T, U>& value) {
+  TrackField("first", value.first);
+  TrackField("second", value.second);
+}
+
+template <typename T>
+void MemoryTracker::TrackField(const char* name,
+                               const std::basic_string<T>& value) {
+  TrackFieldWithSize(name, value.size() * sizeof(T));
+}
+
+template <typename T, typename Traits>
+void MemoryTracker::TrackField(const char* name,
+                               const v8::Persistent<T, Traits>& value) {
+}
+
+template <typename T>
+void MemoryTracker::TrackField(const char* name, const v8::Local<T>& value) {
+}
+
+template <typename T>
+void MemoryTracker::TrackField(const char* name,
+                               const MallocedBuffer<T>& value) {
+  TrackFieldWithSize(name, value.size);
+}
+
+void MemoryTracker::TrackField(const char* name, const uv_buf_t& value) {
+  TrackFieldWithSize(name, value.len);
+}
+
+template <class NativeT, class V8T>
+void MemoryTracker::TrackField(const char* name,
+                       const AliasedBuffer<NativeT, V8T>& value) {
+  TrackField(name, value.GetJSArray());
+}
+
+void MemoryTracker::Track(const MemoryRetainer* value) {
+  value->MemoryInfo(this);
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_MEMORY_TRACKER_INL_H_
diff --git a/src/memory_tracker.h b/src/memory_tracker.h
new file mode 100644
index 00000000000000..18822651f67873
--- /dev/null
+++ b/src/memory_tracker.h
@@ -0,0 +1,87 @@
+#ifndef SRC_MEMORY_TRACKER_H_
+#define SRC_MEMORY_TRACKER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <unordered_set>
+#include <queue>
+#include <limits>
+#include <uv.h>
+#include <aliased_buffer.h>
+
+namespace node {
+
+class MemoryTracker;
+
+namespace crypto {
+class NodeBIO;
+}
+
+class MemoryRetainer {
+ public:
+  virtual ~MemoryRetainer() {}
+
+  // Subclasses should implement this to provide information for heap snapshots.
+  virtual void MemoryInfo(MemoryTracker* tracker) const = 0;
+
+  virtual v8::Local<v8::Object> WrappedObject() const {
+    return v8::Local<v8::Object>();
+  }
+
+  virtual bool IsRootNode() const { return false; }
+};
+
+class MemoryTracker {
+ public:
+  template <typename T>
+  inline void TrackThis(const T* obj);
+
+  inline void TrackFieldWithSize(const char* name, size_t size);
+
+  inline void TrackField(const char* name, const MemoryRetainer& value);
+  inline void TrackField(const char* name, const MemoryRetainer* value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::unique_ptr<T>& value);
+  template <typename T, typename Iterator = typename T::const_iterator>
+  inline void TrackField(const char* name, const T& value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::queue<T>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::basic_string<T>& value);
+  template <typename T, typename test_for_number =
+      typename std::enable_if<
+          std::numeric_limits<T>::is_specialized, bool>::type,
+      typename dummy = bool>
+  inline void TrackField(const char* name, const T& value);
+  template <typename T, typename U>
+  inline void TrackField(const char* name, const std::pair<T, U>& value);
+  template <typename T, typename Traits>
+  inline void TrackField(const char* name,
+                         const v8::Persistent<T, Traits>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const v8::Local<T>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const MallocedBuffer<T>& value);
+  inline void TrackField(const char* name, const uv_buf_t& value);
+  template <class NativeT, class V8T>
+  inline void TrackField(const char* name,
+                         const AliasedBuffer<NativeT, V8T>& value);
+
+  inline void Track(const MemoryRetainer* value);
+  inline size_t accumulated_size() const { return accumulated_size_; }
+
+  inline void set_track_only_self(bool value) { track_only_self_ = value; }
+
+  inline MemoryTracker() {}
+
+ private:
+  bool track_only_self_ = false;
+  size_t accumulated_size_ = 0;
+  std::unordered_set<const MemoryRetainer*> seen_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_MEMORY_TRACKER_H_
diff --git a/src/module_wrap.h b/src/module_wrap.h
index 3969e2a37878fc..2d6f5c49d88988 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -33,6 +33,12 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Module> module,
       v8::Local<v8::Object> meta);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("url", url_);
+    tracker->TrackField("resolve_cache", resolve_cache_);
+  }
+
  private:
   ModuleWrap(Environment* env,
              v8::Local<v8::Object> object,
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index c8155c33ee3d48..b6ef5a37b2c47d 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -587,6 +587,10 @@ class ContextifyScript : public BaseObject {
  private:
   Persistent<UnboundScript> script_;
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  public:
   static void Init(Environment* env, Local<Object> target) {
     HandleScope scope(env->isolate());
diff --git a/src/node_contextify.h b/src/node_contextify.h
index 2ebfef7f27374d..3d94fbc5c47947 100644
--- a/src/node_contextify.h
+++ b/src/node_contextify.h
@@ -49,6 +49,7 @@ class ContextifyContext {
         context()->GetEmbedderData(ContextEmbedderIndex::kSandboxObject));
   }
 
+
   template <typename T>
   static ContextifyContext* Get(const v8::PropertyCallbackInfo<T>& args);
 
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index ba65876e486a93..2c3f983d39e9e5 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -4567,6 +4567,8 @@ bool ECDH::IsKeyPairValid() {
 }
 
 
+// TODO(addaleax): If there is an `AsyncWrap`, it currently has no access to
+// this object. This makes proper reporting of memory usage impossible.
 struct CryptoJob : public ThreadPoolWork {
   Environment* const env;
   std::unique_ptr<AsyncWrap> async_wrap;
diff --git a/src/node_crypto.h b/src/node_crypto.h
index 4587a96e725f86..7df2660c779760 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -105,6 +105,10 @@ class SecureContext : public BaseObject {
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
   SSLCtxPointer ctx_;
   X509Pointer cert_;
   X509Pointer issuer_;
@@ -337,6 +341,10 @@ class CipherBase : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  protected:
   enum CipherKind {
     kCipher,
@@ -407,6 +415,10 @@ class Hmac : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  protected:
   void HmacInit(const char* hash_type, const char* key, int key_len);
   bool HmacUpdate(const char* data, int len);
@@ -430,6 +442,10 @@ class Hash : public BaseObject {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
   bool HashInit(const char* hash_type);
   bool HashUpdate(const char* data, int len);
 
@@ -469,6 +485,10 @@ class SignBase : public BaseObject {
   Error Init(const char* sign_type);
   Error Update(const char* data, int len);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  protected:
   void CheckThrow(Error error);
 
@@ -581,6 +601,10 @@ class DiffieHellman : public BaseObject {
     MakeWeak();
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  private:
   static void GetField(const v8::FunctionCallbackInfo<v8::Value>& args,
                        const BIGNUM* (*get_field)(const DH*),
@@ -606,6 +630,10 @@ class ECDH : public BaseObject {
                                       char* data,
                                       size_t len);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  protected:
   ECDH(Environment* env, v8::Local<v8::Object> wrap, ECKeyPointer&& key)
       : BaseObject(env, wrap),
diff --git a/src/node_crypto_bio.h b/src/node_crypto_bio.h
index 380a3a6b4c64f5..dea010fa0158b4 100644
--- a/src/node_crypto_bio.h
+++ b/src/node_crypto_bio.h
@@ -32,7 +32,7 @@
 namespace node {
 namespace crypto {
 
-class NodeBIO {
+class NodeBIO : public MemoryRetainer {
  public:
   NodeBIO() : env_(nullptr),
               initial_(kInitialBufferLength),
@@ -110,6 +110,11 @@ class NodeBIO {
 
   static NodeBIO* FromBIO(BIO* bio);
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackFieldWithSize("buffer", length_);
+  }
+
  private:
   static int New(BIO* bio);
   static int Free(BIO* bio);
diff --git a/src/node_file.h b/src/node_file.h
index a14a1b0f85e108..6b45dc881750a7 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -66,7 +66,6 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   const char* data() const { return has_data_ ? *buffer_ : nullptr; }
   enum encoding encoding() const { return encoding_; }
 
-  size_t self_size() const override { return sizeof(*this); }
   bool use_bigint() const { return use_bigint_; }
 
  private:
@@ -92,6 +91,10 @@ class FSReqWrap : public FSReqBase {
   void ResolveStat(const uv_stat_t* stat) override;
   void SetReturnValue(const FunctionCallbackInfo<Value>& args) override;
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(FSReqWrap);
 };
@@ -150,6 +153,11 @@ class FSReqPromise : public FSReqBase {
     args.GetReturnValue().Set(resolver->GetPromise());
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("stats_field_array", stats_field_array_);
+  }
+
  private:
   bool finished_ = false;
   AliasedBuffer<NativeT, V8T> stats_field_array_;
@@ -184,7 +192,10 @@ class FileHandleReadWrap : public ReqWrap<uv_fs_t> {
     return static_cast<FileHandleReadWrap*>(ReqWrap::from_req(req));
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("buffer", buffer_);
+  }
 
  private:
   FileHandle* file_handle_;
@@ -205,7 +216,6 @@ class FileHandle : public AsyncWrap, public StreamBase {
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   int fd() const { return fd_; }
-  size_t self_size() const override { return sizeof(*this); }
 
   // Will asynchronously close the FD and return a Promise that will
   // be resolved once closing is complete.
@@ -233,6 +243,11 @@ class FileHandle : public AsyncWrap, public StreamBase {
     return UV_ENOSYS;  // Not implemented (yet).
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("current_read", current_read_);
+  }
+
  private:
   // Synchronous close that emits a warning
   void Close();
@@ -259,7 +274,11 @@ class FileHandle : public AsyncWrap, public StreamBase {
 
     FileHandle* file_handle();
 
-    size_t self_size() const override { return sizeof(*this); }
+    void MemoryInfo(MemoryTracker* tracker) const override {
+      tracker->TrackThis(this);
+      tracker->TrackField("promise", promise_);
+      tracker->TrackField("ref", ref_);
+    }
 
     void Resolve();
 
diff --git a/src/node_http2.cc b/src/node_http2.cc
index e6aeb80a91add9..dfe0e4e7ae3e9a 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -737,7 +737,7 @@ inline void Http2Session::AddStream(Http2Stream* stream) {
   size_t size = streams_.size();
   if (size > statistics_.max_concurrent_streams)
     statistics_.max_concurrent_streams = size;
-  IncrementCurrentSessionMemory(stream->self_size());
+  IncrementCurrentSessionMemory(sizeof(*stream));
 }
 
 
@@ -745,7 +745,7 @@ inline void Http2Session::RemoveStream(Http2Stream* stream) {
   if (streams_.empty() || stream == nullptr)
     return;  // Nothing to remove, item was never added?
   streams_.erase(stream->id());
-  DecrementCurrentSessionMemory(stream->self_size());
+  DecrementCurrentSessionMemory(sizeof(*stream));
 }
 
 // Used as one of the Padding Strategy functions. Will attempt to ensure
@@ -2694,7 +2694,7 @@ Http2Session::Http2Ping* Http2Session::PopPing() {
   if (!outstanding_pings_.empty()) {
     ping = outstanding_pings_.front();
     outstanding_pings_.pop();
-    DecrementCurrentSessionMemory(ping->self_size());
+    DecrementCurrentSessionMemory(sizeof(*ping));
   }
   return ping;
 }
@@ -2703,7 +2703,7 @@ bool Http2Session::AddPing(Http2Session::Http2Ping* ping) {
   if (outstanding_pings_.size() == max_outstanding_pings_)
     return false;
   outstanding_pings_.push(ping);
-  IncrementCurrentSessionMemory(ping->self_size());
+  IncrementCurrentSessionMemory(sizeof(*ping));
   return true;
 }
 
@@ -2712,7 +2712,7 @@ Http2Session::Http2Settings* Http2Session::PopSettings() {
   if (!outstanding_settings_.empty()) {
     settings = outstanding_settings_.front();
     outstanding_settings_.pop();
-    DecrementCurrentSessionMemory(settings->self_size());
+    DecrementCurrentSessionMemory(sizeof(*settings));
   }
   return settings;
 }
@@ -2721,7 +2721,7 @@ bool Http2Session::AddSettings(Http2Session::Http2Settings* settings) {
   if (outstanding_settings_.size() == max_outstanding_settings_)
     return false;
   outstanding_settings_.push(settings);
-  IncrementCurrentSessionMemory(settings->self_size());
+  IncrementCurrentSessionMemory(sizeof(*settings));
   return true;
 }
 
@@ -2766,6 +2766,21 @@ void Http2Session::Http2Ping::Done(bool ack, const uint8_t* payload) {
 }
 
 
+void nghttp2_stream_write::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackThis(this);
+  if (req_wrap != nullptr)
+    tracker->TrackField("req_wrap", req_wrap->GetAsyncWrap());
+  tracker->TrackField("buf", buf);
+}
+
+
+void nghttp2_header::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackThis(this);
+  tracker->TrackFieldWithSize("name", nghttp2_rcbuf_get_buf(name).len);
+  tracker->TrackFieldWithSize("value", nghttp2_rcbuf_get_buf(value).len);
+}
+
+
 // Set up the process.binding('http2') binding.
 void Initialize(Local<Object> target,
                 Local<Value> unused,
diff --git a/src/node_http2.h b/src/node_http2.h
index d90c3aed66b0a0..cbed2a267d171e 100644
--- a/src/node_http2.h
+++ b/src/node_http2.h
@@ -83,19 +83,23 @@ enum nghttp2_stream_options {
   STREAM_OPTION_GET_TRAILERS = 0x2,
 };
 
-struct nghttp2_stream_write {
+struct nghttp2_stream_write : public MemoryRetainer {
   WriteWrap* req_wrap = nullptr;
   uv_buf_t buf;
 
   inline explicit nghttp2_stream_write(uv_buf_t buf_) : buf(buf_) {}
   inline nghttp2_stream_write(WriteWrap* req, uv_buf_t buf_) :
       req_wrap(req), buf(buf_) {}
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
 };
 
-struct nghttp2_header {
+struct nghttp2_header : public MemoryRetainer {
   nghttp2_rcbuf* name = nullptr;
   nghttp2_rcbuf* value = nullptr;
   uint8_t flags = 0;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
 };
 
 
@@ -617,7 +621,12 @@ class Http2Stream : public AsyncWrap,
   int DoWrite(WriteWrap* w, uv_buf_t* bufs, size_t count,
               uv_stream_t* send_handle) override;
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("current_headers", current_headers_);
+    tracker->TrackField("queue", queue_);
+  }
+
   std::string diagnostic_name() const override;
 
   // JavaScript API
@@ -793,7 +802,17 @@ class Http2Session : public AsyncWrap, public StreamListener {
   // Write data to the session
   ssize_t Write(const uv_buf_t* bufs, size_t nbufs);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("streams", streams_);
+    tracker->TrackField("outstanding_pings", outstanding_pings_);
+    tracker->TrackField("outstanding_settings", outstanding_settings_);
+    tracker->TrackField("outgoing_buffers", outgoing_buffers_);
+    tracker->TrackFieldWithSize("outgoing_storage", outgoing_storage_.size());
+    tracker->TrackFieldWithSize("pending_rst_streams",
+                                pending_rst_streams_.size() * sizeof(int32_t));
+  }
+
   std::string diagnostic_name() const override;
 
   // Schedule an RstStream for after the current write finishes.
@@ -1109,7 +1128,10 @@ class Http2Session::Http2Ping : public AsyncWrap {
  public:
   explicit Http2Ping(Http2Session* session);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("session", session_);
+  }
 
   void Send(uint8_t* payload);
   void Done(bool ack, const uint8_t* payload = nullptr);
@@ -1129,7 +1151,10 @@ class Http2Session::Http2Settings : public AsyncWrap {
   explicit Http2Settings(Environment* env);
   explicit Http2Settings(Http2Session* session);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("session", session_);
+  }
 
   void Send();
   void Done(bool ack);
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index 7d96466c3933fc..e8fc1f22e4938a 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -155,8 +155,9 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
-  size_t self_size() const override {
-    return sizeof(*this);
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("current_buffer", current_buffer_);
   }
 
 
diff --git a/src/node_i18n.cc b/src/node_i18n.cc
index 4ace513810f1b8..288ad77f619188 100644
--- a/src/node_i18n.cc
+++ b/src/node_i18n.cc
@@ -250,6 +250,10 @@ class ConverterObject : public BaseObject, Converter {
     }
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  protected:
   ConverterObject(Environment* env,
                   v8::Local<v8::Object> wrap,
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 712add06d3e2bc..c28d0d4ea66560 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -325,6 +325,14 @@ Maybe<bool> Message::Serialize(Environment* env,
   return Just(true);
 }
 
+void Message::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackThis(this);
+  tracker->TrackField("array_buffer_contents", array_buffer_contents_);
+  tracker->TrackFieldWithSize("shared_array_buffers",
+      shared_array_buffers_.size() * sizeof(shared_array_buffers_[0]));
+  tracker->TrackField("message_ports", message_ports_);
+}
+
 MessagePortData::MessagePortData(MessagePort* owner) : owner_(owner) { }
 
 MessagePortData::~MessagePortData() {
@@ -332,6 +340,12 @@ MessagePortData::~MessagePortData() {
   Disentangle();
 }
 
+void MessagePortData::MemoryInfo(MemoryTracker* tracker) const {
+  Mutex::ScopedLock lock(mutex_);
+  tracker->TrackThis(this);
+  tracker->TrackField("incoming_messages", incoming_messages_);
+}
+
 void MessagePortData::AddToIncomingQueue(Message&& message) {
   // This function will be called by other threads.
   Mutex::ScopedLock lock(mutex_);
@@ -688,14 +702,6 @@ void MessagePort::Drain(const FunctionCallbackInfo<Value>& args) {
   port->OnMessage();
 }
 
-size_t MessagePort::self_size() const {
-  Mutex::ScopedLock lock(data_->mutex_);
-  size_t sz = sizeof(*this) + sizeof(*data_);
-  for (const Message& msg : data_->incoming_messages_)
-    sz += sizeof(msg) + msg.main_message_buf_.size;
-  return sz;
-}
-
 void MessagePort::Entangle(MessagePort* a, MessagePort* b) {
   Entangle(a, b->data_.get());
 }
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 62ae633b9e0b8d..da10300aedbd42 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -15,7 +15,7 @@ class MessagePortData;
 class MessagePort;
 
 // Represents a single communication message.
-class Message {
+class Message : public MemoryRetainer {
  public:
   explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
 
@@ -55,6 +55,8 @@ class Message {
     return message_ports_;
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
  private:
   MallocedBuffer<char> main_message_buf_;
   std::vector<MallocedBuffer<char>> array_buffer_contents_;
@@ -66,7 +68,7 @@ class Message {
 
 // This contains all data for a `MessagePort` instance that is not tied to
 // a specific Environment/Isolate/event loop, for easier transfer between those.
-class MessagePortData {
+class MessagePortData : public MemoryRetainer {
  public:
   explicit MessagePortData(MessagePort* owner);
   ~MessagePortData();
@@ -94,6 +96,8 @@ class MessagePortData {
   // which can happen on either side of a worker.
   void Disentangle();
 
+  void MemoryInfo(MemoryTracker* tracker) const override;
+
  private:
   // After disentangling this message port, the owner handle (if any)
   // is asynchronously triggered, so that it can close down naturally.
@@ -178,7 +182,10 @@ class MessagePort : public HandleWrap {
   // NULL pointer to the C++ MessagePort object is also detached.
   inline bool IsDetached() const;
 
-  size_t self_size() const override;
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("data", data_);
+  }
 
  private:
   void OnClose() override;
diff --git a/src/node_serdes.cc b/src/node_serdes.cc
index 520b350199245a..4b2cc60b3f7584 100644
--- a/src/node_serdes.cc
+++ b/src/node_serdes.cc
@@ -52,6 +52,11 @@ class SerializerContext : public BaseObject,
   static void WriteUint64(const FunctionCallbackInfo<Value>& args);
   static void WriteDouble(const FunctionCallbackInfo<Value>& args);
   static void WriteRawBytes(const FunctionCallbackInfo<Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  private:
   ValueSerializer serializer_;
 };
@@ -76,6 +81,11 @@ class DeserializerContext : public BaseObject,
   static void ReadUint64(const FunctionCallbackInfo<Value>& args);
   static void ReadDouble(const FunctionCallbackInfo<Value>& args);
   static void ReadRawBytes(const FunctionCallbackInfo<Value>& args);
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  private:
   const uint8_t* data_;
   const size_t length_;
diff --git a/src/node_stat_watcher.h b/src/node_stat_watcher.h
index 45150de785f9d1..baf6bdc14ee317 100644
--- a/src/node_stat_watcher.h
+++ b/src/node_stat_watcher.h
@@ -44,7 +44,9 @@ class StatWatcher : public HandleWrap {
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   static void Callback(uv_fs_poll_t* handle,
diff --git a/src/node_trace_events.cc b/src/node_trace_events.cc
index 985c706dc4a2f1..0904311dad865b 100644
--- a/src/node_trace_events.cc
+++ b/src/node_trace_events.cc
@@ -27,6 +27,11 @@ class NodeCategorySet : public BaseObject {
 
   const std::set<std::string>& GetCategories() { return categories_; }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackField("categories", categories_);
+  }
+
  private:
   NodeCategorySet(Environment* env,
                   Local<Object> wrap,
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 6f325668b86921..3768d80a9c58d4 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -403,10 +403,6 @@ void Worker::Exit(int code) {
   }
 }
 
-size_t Worker::self_size() const {
-  return sizeof(*this);
-}
-
 namespace {
 
 // Return the MessagePort that is global for this Environment and communicates
diff --git a/src/node_worker.h b/src/node_worker.h
index d802b5cfefdf77..bd737d4800fd79 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -25,7 +25,14 @@ class Worker : public AsyncWrap {
   // Wait for the worker thread to stop (in a blocking manner).
   void JoinThread();
 
-  size_t self_size() const override;
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackFieldWithSize("isolate_data", sizeof(IsolateData));
+    tracker->TrackFieldWithSize("env", sizeof(Environment));
+    tracker->TrackFieldWithSize("thread_exit_async", sizeof(uv_async_t));
+    tracker->TrackField("parent_port", parent_port_);
+  }
+
   bool is_stopped() const;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 169816d16f48b6..031666e19ad29c 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -646,7 +646,12 @@ class ZCtx : public AsyncWrap, public ThreadPoolWork {
     }
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackFieldWithSize("dictionary", dictionary_len_);
+    tracker->TrackFieldWithSize("zlib memory",
+        zlib_memory_ + unreported_allocations_);
+  }
 
  private:
   void Ref() {
diff --git a/src/pipe_wrap.h b/src/pipe_wrap.h
index d6e45c28ff7822..9ed4f153ae5c4c 100644
--- a/src/pipe_wrap.h
+++ b/src/pipe_wrap.h
@@ -45,7 +45,9 @@ class PipeWrap : public ConnectionWrap<PipeWrap, uv_pipe_t> {
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   PipeWrap(Environment* env,
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 54345b231bccce..3219b1a40b9c16 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -71,7 +71,9 @@ class ProcessWrap : public HandleWrap {
     target->Set(processString, constructor->GetFunction());
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   static void New(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/sharedarraybuffer_metadata.cc b/src/sharedarraybuffer_metadata.cc
index 86476a9f12c38b..95fed87c8d4ea0 100644
--- a/src/sharedarraybuffer_metadata.cc
+++ b/src/sharedarraybuffer_metadata.cc
@@ -47,6 +47,10 @@ class SABLifetimePartner : public BaseObject {
     MakeWeak();
   }
 
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
   SharedArrayBufferMetadataReference reference;
 };
 
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index 5117d3ab1d1988..346f442f61df0f 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -62,7 +62,9 @@ class SignalWrap : public HandleWrap {
     target->Set(signalString, constructor->GetFunction());
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   static void New(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/stream_base.h b/src/stream_base.h
index 405780619856ba..bbb20e52e1a8de 100644
--- a/src/stream_base.h
+++ b/src/stream_base.h
@@ -346,7 +346,10 @@ class SimpleShutdownWrap : public ShutdownWrap, public OtherBase {
                      v8::Local<v8::Object> req_wrap_obj);
 
   AsyncWrap* GetAsyncWrap() override { return this; }
-  size_t self_size() const override { return sizeof(*this); }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 };
 
 template <typename OtherBase>
@@ -356,7 +359,11 @@ class SimpleWriteWrap : public WriteWrap, public OtherBase {
                   v8::Local<v8::Object> req_wrap_obj);
 
   AsyncWrap* GetAsyncWrap() override { return this; }
-  size_t self_size() const override { return sizeof(*this) + StorageSize(); }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+    tracker->TrackFieldWithSize("storage", StorageSize());
+  }
 };
 
 }  // namespace node
diff --git a/src/stream_pipe.h b/src/stream_pipe.h
index 98d6dae11be841..b72a60941b610a 100644
--- a/src/stream_pipe.h
+++ b/src/stream_pipe.h
@@ -18,7 +18,9 @@ class StreamPipe : public AsyncWrap {
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Unpipe(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   StreamBase* source();
diff --git a/src/tcp_wrap.h b/src/tcp_wrap.h
index 2ab50f1fdcdfab..d6ca9306099e37 100644
--- a/src/tcp_wrap.h
+++ b/src/tcp_wrap.h
@@ -44,7 +44,9 @@ class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context);
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   typedef uv_tcp_t HandleType;
diff --git a/src/timer_wrap.cc b/src/timer_wrap.cc
index 50541acc9b8a0d..9bce195203d686 100644
--- a/src/timer_wrap.cc
+++ b/src/timer_wrap.cc
@@ -72,7 +72,9 @@ class TimerWrap : public HandleWrap {
                    ->GetFunction(env->context()).ToLocalChecked()).FromJust();
   }
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   static void SetupTimers(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index e731c0c130216b..0d0791b710c860 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -864,6 +864,15 @@ void TLSWrap::GetWriteQueueSize(const FunctionCallbackInfo<Value>& info) {
 }
 
 
+void TLSWrap::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackThis(this);
+  tracker->TrackField("error", error_);
+  tracker->TrackField("pending_cleartext_input", pending_cleartext_input_);
+  tracker->TrackField("enc_in", crypto::NodeBIO::FromBIO(enc_in_));
+  tracker->TrackField("enc_out", crypto::NodeBIO::FromBIO(enc_out_));
+}
+
+
 void TLSWrap::Initialize(Local<Object> target,
                          Local<Value> unused,
                          Local<Context> context) {
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index 1603d8919a472c..b45e379ca3f61c 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -76,7 +76,7 @@ class TLSWrap : public AsyncWrap,
 
   void NewSessionDoneCb();
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override;
 
  protected:
   inline StreamBase* underlying_stream() {
diff --git a/src/tty_wrap.h b/src/tty_wrap.h
index 91b07a570e9b50..cca5650ddb3964 100644
--- a/src/tty_wrap.h
+++ b/src/tty_wrap.h
@@ -38,7 +38,9 @@ class TTYWrap : public LibuvStreamWrap {
 
   uv_tty_t* UVHandle();
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   TTYWrap(Environment* env,
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 1d1ded449bd221..49f66914e2aa81 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -55,7 +55,11 @@ class SendWrap : public ReqWrap<uv_udp_send_t> {
   SendWrap(Environment* env, Local<Object> req_wrap_obj, bool have_callback);
   inline bool have_callback() const;
   size_t msg_size;
-  size_t self_size() const override { return sizeof(*this); }
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+
  private:
   const bool have_callback_;
 };
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index 01eb8b961f0cf2..3792bcc459da23 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -64,7 +64,9 @@ class UDPWrap: public HandleWrap {
                                            SocketType type);
   uv_udp_t* UVHandle();
 
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
  private:
   typedef uv_udp_t HandleType;
diff --git a/test/cctest/test_node_postmortem_metadata.cc b/test/cctest/test_node_postmortem_metadata.cc
index f69df3ed227717..6f5db0fdf9272b 100644
--- a/test/cctest/test_node_postmortem_metadata.cc
+++ b/test/cctest/test_node_postmortem_metadata.cc
@@ -34,7 +34,9 @@ class DebugSymbolsTest : public EnvironmentTestFixture {};
 
 class TestHandleWrap : public node::HandleWrap {
  public:
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(node::MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
   TestHandleWrap(node::Environment* env,
                  v8::Local<v8::Object> object,
@@ -48,7 +50,9 @@ class TestHandleWrap : public node::HandleWrap {
 
 class TestReqWrap : public node::ReqWrap<uv_req_t> {
  public:
-  size_t self_size() const override { return sizeof(*this); }
+  void MemoryInfo(node::MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
 
   TestReqWrap(node::Environment* env, v8::Local<v8::Object> object)
       : node::ReqWrap<uv_req_t>(env,
@@ -67,6 +71,16 @@ TEST_F(DebugSymbolsTest, ExternalStringDataOffset) {
             NODE_OFF_EXTSTR_DATA);
 }
 
+class DummyBaseObject : public node::BaseObject {
+ public:
+  DummyBaseObject(node::Environment* env, v8::Local<v8::Object> obj) :
+    BaseObject(env, obj) {}
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override {
+    tracker->TrackThis(this);
+  }
+};
+
 TEST_F(DebugSymbolsTest, BaseObjectPersistentHandle) {
   const v8::HandleScope handle_scope(isolate_);
   const Argv argv;
@@ -77,7 +91,7 @@ TEST_F(DebugSymbolsTest, BaseObjectPersistentHandle) {
 
   v8::Local<v8::Object> object =
       obj_templ->NewInstance(env.context()).ToLocalChecked();
-  node::BaseObject obj(*env, object);
+  DummyBaseObject obj(*env, object);
 
   auto expected = reinterpret_cast<uintptr_t>(&obj.persistent());
   auto calculated = reinterpret_cast<uintptr_t>(&obj) +

From ada3f34cd4082454edef127c534c16579256c535 Mon Sep 17 00:00:00 2001
From: Jon Moss <me@jonathanmoss.me>
Date: Fri, 13 Jul 2018 10:45:42 -0400
Subject: [PATCH 063/116] test: fix weird string error

Previously getting this error when running `tap2junit` (what parses our
`.tap` files in CI):

```
Traceback (most recent call last):
  File "/usr/local/bin/tap2junit", line 11, in <module>
    sys.exit(main())
  File "/usr/local/lib/python2.7/site-packages/tap2junit/__main__.py", line 46, in main
    result.to_file(args.output, [result], prettyprint=False)
  File "/usr/local/lib/python2.7/site-packages/junit_xml/__init__.py", line 289, in to_file
    test_suites, prettyprint=prettyprint, encoding=encoding)
  File "/usr/local/lib/python2.7/site-packages/junit_xml/__init__.py", line 257, in to_xml_string
    ts_xml = ts.build_xml_doc(encoding=encoding)
  File "/usr/local/lib/python2.7/site-packages/junit_xml/__init__.py", line 221, in build_xml_doc
    attrs['message'] = decode(case.skipped_message, encoding)
  File "/usr/local/lib/python2.7/site-packages/junit_xml/__init__.py", line 68, in decode
    ret = unicode(var)
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 11: ordinal not in range(128)
```

PR-URL: https://github.com/nodejs/node/pull/21793
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/parallel/test-stdio-pipe-access.js   | 2 +-
 test/parallel/test-stdio-pipe-redirect.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/parallel/test-stdio-pipe-access.js b/test/parallel/test-stdio-pipe-access.js
index d32c5f0ba9c2e7..084fa4c038e7da 100644
--- a/test/parallel/test-stdio-pipe-access.js
+++ b/test/parallel/test-stdio-pipe-access.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../common');
 if (!common.isMainThread)
-  common.skip('Workers don’t have process-like stdio');
+  common.skip("Workers don't have process-like stdio");
 
 // Test if Node handles acessing process.stdin if it is a redirected
 // pipe without deadlocking
diff --git a/test/parallel/test-stdio-pipe-redirect.js b/test/parallel/test-stdio-pipe-redirect.js
index 60f16b5cb2f6df..fbde6ef8085457 100644
--- a/test/parallel/test-stdio-pipe-redirect.js
+++ b/test/parallel/test-stdio-pipe-redirect.js
@@ -1,7 +1,7 @@
 'use strict';
 const common = require('../common');
 if (!common.isMainThread)
-  common.skip('Workers don’t have process-like stdio');
+  common.skip("Workers don't have process-like stdio");
 
 // Test if Node handles redirecting one child process stdout to another
 // process stdin without crashing.

From 7ab6efdb94905b0134bb2e816d9526a8e8c738fa Mon Sep 17 00:00:00 2001
From: Myles Borins <mylesborins@google.com>
Date: Fri, 29 Jun 2018 18:49:42 -0400
Subject: [PATCH 064/116] doc: add policy for landing new npm releases

This change in policy sets clear terms for when / how npm releases
can be landed into master and how long they are expected to bake in the
ecosystem. This is to cover all release types of npm including semver-major
releases.

What Node.js releases the updates land into are at the discretion of the
release team.

PR-URL: https://github.com/nodejs/node/pull/21594
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
---
 doc/guides/maintaining-npm.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/doc/guides/maintaining-npm.md b/doc/guides/maintaining-npm.md
index 97da87feee64d3..6017e78fded70a 100644
--- a/doc/guides/maintaining-npm.md
+++ b/doc/guides/maintaining-npm.md
@@ -1,5 +1,19 @@
 # Maintaining npm in Node.js
 
+New pull requests should be opened when a "next" version of npm has
+been released. Once the "next" version has been promoted to "latest"
+the PR should be updated as necessary.
+
+Two weeks after the "latest" release has been promoted it can land on master
+assuming no major regressions are found. There are no additional constraints
+for Semver-Major releases.
+
+The specific Node.js release streams the new version will be able to land into
+are at the discretion of the release and LTS teams.
+
+This process only covers full updates to new versions of npm. Cherry-picked
+changes can be reviewed and landed via the normal consensus seeking process.
+
 ## Step 1: Clone npm
 
 ```console

From 42d75392c522823f89aab2f1f0514612365b3e85 Mon Sep 17 00:00:00 2001
From: Myles Borins <mylesborins@google.com>
Date: Mon, 9 Jul 2018 16:22:46 -0400
Subject: [PATCH 065/116] deps: patch V8 to 6.7.288.49
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21727
Refs: https://github.com/v8/v8/compare/6.7.288.46...6.7.288.49
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 deps/v8/DEPS                 | 2 ++
 deps/v8/include/v8-version.h | 2 +-
 deps/v8/tools/whitespace.txt | 4 +---
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/deps/v8/DEPS b/deps/v8/DEPS
index 4a00478633793d..7c4fe68361593d 100644
--- a/deps/v8/DEPS
+++ b/deps/v8/DEPS
@@ -15,6 +15,8 @@ deps = {
     Var('chromium_url') + '/chromium/src/build.git' + '@' + '73e352e758d90603e23bdc84734c12aa5817ab5f',
   'v8/tools/gyp':
     Var('chromium_url') + '/external/gyp.git' + '@' + 'd61a9397e668fa9843c4aa7da9e79460fe590bfb',
+  'v8/third_party/depot_tools':
+    Var('chromium_url') + '/chromium/tools/depot_tools.git' + '@' + '024a3317597b06418efea2d45aa54dd2a7030c8a',
   'v8/third_party/icu':
     Var('chromium_url') + '/chromium/deps/icu.git' + '@' + 'd888fd2a1be890f4d35e43f68d6d79f42519a357',
   'v8/third_party/instrumented_libraries':
diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h
index 440a6068699ef0..09c47d7e91196d 100644
--- a/deps/v8/include/v8-version.h
+++ b/deps/v8/include/v8-version.h
@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 6
 #define V8_MINOR_VERSION 7
 #define V8_BUILD_NUMBER 288
-#define V8_PATCH_LEVEL 46
+#define V8_PATCH_LEVEL 49
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)
diff --git a/deps/v8/tools/whitespace.txt b/deps/v8/tools/whitespace.txt
index ed5e51f96a63e8..8a1a4d64c7aac8 100644
--- a/deps/v8/tools/whitespace.txt
+++ b/deps/v8/tools/whitespace.txt
@@ -7,6 +7,4 @@ A Smi balks into a war and says:
 The doubles heard this and started to unbox.
 The Smi looked at them when a crazy v8-autoroll account showed up...
 The autoroller bought a round of Himbeerbrause. Suddenly...
-The bartender starts to shake the bottles.......................
-.
-.
+The bartender starts to shake the bottles...

From b2291296efb942f863f69b4be4d7059a123ebd7c Mon Sep 17 00:00:00 2001
From: Eugene Ostroukhov <eostroukhov@google.com>
Date: Mon, 21 May 2018 16:59:04 -0700
Subject: [PATCH 066/116] inspector: split main thread interface from transport

Workers debugging will require interfacing between the "main" inspector
and per-worker isolate inspectors. This is consistent with what WS
interface does. This change is a refactoring change and does not change
the functionality.

PR-URL: https://github.com/nodejs/node/pull/21182
Fixes: https://github.com/nodejs/node/issues/21725
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 node.gyp                                    |   4 +-
 src/inspector/main_thread_interface.cc      | 317 +++++++++++
 src/inspector/main_thread_interface.h       |  99 ++++
 src/inspector_agent.cc                      | 285 ++++++----
 src/inspector_agent.h                       |  39 +-
 src/inspector_io.cc                         | 549 ++++++++------------
 src/inspector_io.h                          | 142 ++---
 src/inspector_js_api.cc                     |  11 +-
 src/inspector_socket_server.cc              |  31 +-
 src/inspector_socket_server.h               |   4 -
 src/node.cc                                 |  11 +-
 src/signal_wrap.cc                          |   2 +-
 test/cctest/test_inspector_socket_server.cc |  29 +-
 test/parallel/test-warn-sigprof.js          |   1 +
 14 files changed, 890 insertions(+), 634 deletions(-)
 create mode 100644 src/inspector/main_thread_interface.cc
 create mode 100644 src/inspector/main_thread_interface.h

diff --git a/node.gyp b/node.gyp
index ae254278198edf..e0bd57dde51686 100644
--- a/node.gyp
+++ b/node.gyp
@@ -490,12 +490,14 @@
             'src/inspector_js_api.cc',
             'src/inspector_socket.cc',
             'src/inspector_socket_server.cc',
-            'src/inspector/tracing_agent.cc',
+            'src/inspector/main_thread_interface.cc',
             'src/inspector/node_string.cc',
+            'src/inspector/tracing_agent.cc',
             'src/inspector_agent.h',
             'src/inspector_io.h',
             'src/inspector_socket.h',
             'src/inspector_socket_server.h',
+            'src/inspector/main_thread_interface.h',
             'src/inspector/node_string.h',
             'src/inspector/tracing_agent.h',
             '<@(node_inspector_generated_sources)'
diff --git a/src/inspector/main_thread_interface.cc b/src/inspector/main_thread_interface.cc
new file mode 100644
index 00000000000000..da43c95bea5fe3
--- /dev/null
+++ b/src/inspector/main_thread_interface.cc
@@ -0,0 +1,317 @@
+#include "main_thread_interface.h"
+
+#include "node_mutex.h"
+#include "v8-inspector.h"
+
+#include <unicode/unistr.h>
+
+namespace node {
+namespace inspector {
+namespace {
+
+using v8_inspector::StringView;
+using v8_inspector::StringBuffer;
+
+template <typename T>
+class DeleteRequest : public Request {
+ public:
+  explicit DeleteRequest(T* object) : object_(object) {}
+  void Call() override {
+    delete object_;
+  }
+
+ private:
+  T* object_;
+};
+
+template <typename Target, typename Arg>
+class SingleArgumentFunctionCall : public Request {
+ public:
+  using Fn = void (Target::*)(Arg);
+
+  SingleArgumentFunctionCall(Target* target, Fn fn, Arg argument)
+                             : target_(target),
+                               fn_(fn),
+                               arg_(std::move(argument)) {}
+
+  void Call() override {
+    Apply(target_, fn_, std::move(arg_));
+  }
+
+ private:
+  template <typename Element>
+  void Apply(Element* target, Fn fn, Arg arg) {
+    (target->*fn)(std::move(arg));
+  }
+
+  Target* target_;
+  Fn fn_;
+  Arg arg_;
+};
+
+class PostMessageRequest : public Request {
+ public:
+  PostMessageRequest(InspectorSessionDelegate* delegate,
+                     StringView message)
+                     : delegate_(delegate),
+                       message_(StringBuffer::create(message)) {}
+
+  void Call() override {
+    delegate_->SendMessageToFrontend(message_->string());
+  }
+
+ private:
+  InspectorSessionDelegate* delegate_;
+  std::unique_ptr<StringBuffer> message_;
+};
+
+class DispatchMessagesTask : public v8::Task {
+ public:
+  explicit DispatchMessagesTask(MainThreadInterface* thread)
+                                : thread_(thread) {}
+
+  void Run() override {
+    thread_->DispatchMessages();
+  }
+
+ private:
+  MainThreadInterface* thread_;
+};
+
+void DisposePairCallback(uv_handle_t* ref) {
+  using AsyncAndInterface = std::pair<uv_async_t, MainThreadInterface*>;
+  AsyncAndInterface* pair = node::ContainerOf(
+      &AsyncAndInterface::first, reinterpret_cast<uv_async_t*>(ref));
+  delete pair;
+}
+
+template <typename T>
+class AnotherThreadObjectReference {
+ public:
+  // We create it on whatever thread, just make sure it gets disposed on the
+  // proper thread.
+  AnotherThreadObjectReference(std::shared_ptr<MainThreadHandle> thread,
+                               T* object)
+                               : thread_(thread), object_(object) {
+  }
+  AnotherThreadObjectReference(AnotherThreadObjectReference&) = delete;
+
+  ~AnotherThreadObjectReference() {
+    // Disappearing thread may cause a memory leak
+    CHECK(thread_->Post(
+        std::unique_ptr<DeleteRequest<T>>(new DeleteRequest<T>(object_))));
+    object_ = nullptr;
+  }
+
+  template <typename Fn, typename Arg>
+  void Post(Fn fn, Arg argument) const {
+    using R = SingleArgumentFunctionCall<T, Arg>;
+    thread_->Post(std::unique_ptr<R>(new R(object_, fn, std::move(argument))));
+  }
+
+  T* get() const {
+    return object_;
+  }
+
+ private:
+  std::shared_ptr<MainThreadHandle> thread_;
+  T* object_;
+};
+
+class MainThreadSessionState {
+ public:
+  MainThreadSessionState(
+      std::shared_ptr<MainThreadHandle> thread,
+      bool prevent_shutdown) : thread_(thread),
+                               prevent_shutdown_(prevent_shutdown) {}
+
+  void Connect(std::unique_ptr<InspectorSessionDelegate> delegate) {
+    Agent* agent = thread_->GetInspectorAgent();
+    if (agent != nullptr)
+      session_ = agent->Connect(std::move(delegate), prevent_shutdown_);
+  }
+
+  void Dispatch(std::unique_ptr<StringBuffer> message) {
+    session_->Dispatch(message->string());
+  }
+
+ private:
+  std::shared_ptr<MainThreadHandle> thread_;
+  bool prevent_shutdown_;
+  std::unique_ptr<InspectorSession> session_;
+};
+
+class CrossThreadInspectorSession : public InspectorSession {
+ public:
+  CrossThreadInspectorSession(
+      int id,
+      std::shared_ptr<MainThreadHandle> thread,
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown)
+      : state_(thread, new MainThreadSessionState(thread, prevent_shutdown)) {
+    state_.Post(&MainThreadSessionState::Connect, std::move(delegate));
+  }
+
+  void Dispatch(const StringView& message) override {
+    state_.Post(&MainThreadSessionState::Dispatch,
+                StringBuffer::create(message));
+  }
+
+ private:
+  AnotherThreadObjectReference<MainThreadSessionState> state_;
+};
+
+class ThreadSafeDelegate : public InspectorSessionDelegate {
+ public:
+  ThreadSafeDelegate(std::shared_ptr<MainThreadHandle> thread,
+                     std::unique_ptr<InspectorSessionDelegate> delegate)
+                     : thread_(thread), delegate_(thread, delegate.release()) {}
+
+  void SendMessageToFrontend(const v8_inspector::StringView& message) override {
+    thread_->Post(std::unique_ptr<Request>(
+        new PostMessageRequest(delegate_.get(), message)));
+  }
+
+ private:
+  std::shared_ptr<MainThreadHandle> thread_;
+  AnotherThreadObjectReference<InspectorSessionDelegate> delegate_;
+};
+}  // namespace
+
+
+MainThreadInterface::MainThreadInterface(Agent* agent, uv_loop_t* loop,
+                                         v8::Isolate* isolate,
+                                         v8::Platform* platform)
+                                         : agent_(agent), isolate_(isolate),
+                                           platform_(platform) {
+  main_thread_request_.reset(new AsyncAndInterface(uv_async_t(), this));
+  CHECK_EQ(0, uv_async_init(loop, &main_thread_request_->first,
+                            DispatchMessagesAsyncCallback));
+  // Inspector uv_async_t should not prevent main loop shutdown.
+  uv_unref(reinterpret_cast<uv_handle_t*>(&main_thread_request_->first));
+}
+
+MainThreadInterface::~MainThreadInterface() {
+  if (handle_)
+    handle_->Reset();
+}
+
+// static
+void MainThreadInterface::DispatchMessagesAsyncCallback(uv_async_t* async) {
+  AsyncAndInterface* asyncAndInterface =
+      node::ContainerOf(&AsyncAndInterface::first, async);
+  asyncAndInterface->second->DispatchMessages();
+}
+
+// static
+void MainThreadInterface::CloseAsync(AsyncAndInterface* pair) {
+  uv_close(reinterpret_cast<uv_handle_t*>(&pair->first), DisposePairCallback);
+}
+
+void MainThreadInterface::Post(std::unique_ptr<Request> request) {
+  Mutex::ScopedLock scoped_lock(requests_lock_);
+  bool needs_notify = requests_.empty();
+  requests_.push_back(std::move(request));
+  if (needs_notify) {
+    CHECK_EQ(0, uv_async_send(&main_thread_request_->first));
+    if (isolate_ != nullptr && platform_ != nullptr) {
+      platform_->CallOnForegroundThread(isolate_,
+                                        new DispatchMessagesTask(this));
+      isolate_->RequestInterrupt([](v8::Isolate* isolate, void* thread) {
+        static_cast<MainThreadInterface*>(thread)->DispatchMessages();
+      }, this);
+    }
+  }
+  incoming_message_cond_.Broadcast(scoped_lock);
+}
+
+bool MainThreadInterface::WaitForFrontendEvent() {
+  // We allow DispatchMessages reentry as we enter the pause. This is important
+  // to support debugging the code invoked by an inspector call, such
+  // as Runtime.evaluate
+  dispatching_messages_ = false;
+  if (dispatching_message_queue_.empty()) {
+    Mutex::ScopedLock scoped_lock(requests_lock_);
+    while (requests_.empty()) incoming_message_cond_.Wait(scoped_lock);
+  }
+  return true;
+}
+
+void MainThreadInterface::DispatchMessages() {
+  if (dispatching_messages_)
+    return;
+  dispatching_messages_ = true;
+  bool had_messages = false;
+  do {
+    if (dispatching_message_queue_.empty()) {
+      Mutex::ScopedLock scoped_lock(requests_lock_);
+      requests_.swap(dispatching_message_queue_);
+    }
+    had_messages = !dispatching_message_queue_.empty();
+    while (!dispatching_message_queue_.empty()) {
+      MessageQueue::value_type task;
+      std::swap(dispatching_message_queue_.front(), task);
+      dispatching_message_queue_.pop_front();
+      task->Call();
+    }
+  } while (had_messages);
+  dispatching_messages_ = false;
+}
+
+std::shared_ptr<MainThreadHandle> MainThreadInterface::GetHandle() {
+  if (handle_ == nullptr)
+    handle_ = std::make_shared<MainThreadHandle>(this);
+  return handle_;
+}
+
+std::unique_ptr<StringBuffer> Utf8ToStringView(const std::string& message) {
+  icu::UnicodeString utf16 = icu::UnicodeString::fromUTF8(
+      icu::StringPiece(message.data(), message.length()));
+  StringView view(reinterpret_cast<const uint16_t*>(utf16.getBuffer()),
+                  utf16.length());
+  return StringBuffer::create(view);
+}
+
+std::unique_ptr<InspectorSession> MainThreadHandle::Connect(
+    std::unique_ptr<InspectorSessionDelegate> delegate,
+    bool prevent_shutdown) {
+  return std::unique_ptr<InspectorSession>(
+      new CrossThreadInspectorSession(++next_session_id_,
+                                      shared_from_this(),
+                                      std::move(delegate),
+                                      prevent_shutdown));
+}
+
+bool MainThreadHandle::Post(std::unique_ptr<Request> request) {
+  Mutex::ScopedLock scoped_lock(block_lock_);
+  if (!main_thread_)
+    return false;
+  main_thread_->Post(std::move(request));
+  return true;
+}
+
+void MainThreadHandle::Reset() {
+  Mutex::ScopedLock scoped_lock(block_lock_);
+  main_thread_ = nullptr;
+}
+
+Agent* MainThreadHandle::GetInspectorAgent() {
+  Mutex::ScopedLock scoped_lock(block_lock_);
+  if (main_thread_ == nullptr)
+    return nullptr;
+  return main_thread_->inspector_agent();
+}
+
+std::unique_ptr<InspectorSessionDelegate>
+MainThreadHandle::MakeThreadSafeDelegate(
+    std::unique_ptr<InspectorSessionDelegate> delegate) {
+  return std::unique_ptr<InspectorSessionDelegate>(
+      new ThreadSafeDelegate(shared_from_this(), std::move(delegate)));
+}
+
+bool MainThreadHandle::Expired() {
+  Mutex::ScopedLock scoped_lock(block_lock_);
+  return main_thread_ == nullptr;
+}
+}  // namespace inspector
+}  // namespace node
diff --git a/src/inspector/main_thread_interface.h b/src/inspector/main_thread_interface.h
new file mode 100644
index 00000000000000..75df5ffe809048
--- /dev/null
+++ b/src/inspector/main_thread_interface.h
@@ -0,0 +1,99 @@
+#ifndef SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+#define SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
+
+#if !HAVE_INSPECTOR
+#error("This header can only be used when inspector is enabled")
+#endif
+
+#include "env.h"
+#include "inspector_agent.h"
+#include "node_mutex.h"
+
+#include <deque>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace v8_inspector {
+class StringBuffer;
+class StringView;
+}  // namespace v8_inspector
+
+namespace node {
+namespace inspector {
+class Request {
+ public:
+  virtual void Call() = 0;
+  virtual ~Request() {}
+};
+
+std::unique_ptr<v8_inspector::StringBuffer> Utf8ToStringView(
+    const std::string& message);
+
+using MessageQueue = std::deque<std::unique_ptr<Request>>;
+class MainThreadInterface;
+
+class MainThreadHandle : public std::enable_shared_from_this<MainThreadHandle> {
+ public:
+  explicit MainThreadHandle(MainThreadInterface* main_thread)
+                            : main_thread_(main_thread) {}
+  ~MainThreadHandle() {
+    CHECK_NULL(main_thread_);  // main_thread_ should have called Reset
+  }
+  std::unique_ptr<InspectorSession> Connect(
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
+  bool Post(std::unique_ptr<Request> request);
+  Agent* GetInspectorAgent();
+  std::unique_ptr<InspectorSessionDelegate> MakeThreadSafeDelegate(
+      std::unique_ptr<InspectorSessionDelegate> delegate);
+  bool Expired();
+
+ private:
+  void Reset();
+
+  MainThreadInterface* main_thread_;
+  Mutex block_lock_;
+  int next_session_id_ = 0;
+
+  friend class MainThreadInterface;
+};
+
+class MainThreadInterface {
+ public:
+  MainThreadInterface(Agent* agent, uv_loop_t*, v8::Isolate* isolate,
+                      v8::Platform* platform);
+  ~MainThreadInterface();
+
+  void DispatchMessages();
+  void Post(std::unique_ptr<Request> request);
+  bool WaitForFrontendEvent();
+  std::shared_ptr<MainThreadHandle> GetHandle();
+  Agent* inspector_agent() {
+    return agent_;
+  }
+
+ private:
+  using AsyncAndInterface = std::pair<uv_async_t, MainThreadInterface*>;
+
+  static void DispatchMessagesAsyncCallback(uv_async_t* async);
+  static void CloseAsync(AsyncAndInterface*);
+
+  MessageQueue requests_;
+  Mutex requests_lock_;   // requests_ live across threads
+  // This queue is to maintain the order of the messages for the cases
+  // when we reenter the DispatchMessages function.
+  MessageQueue dispatching_message_queue_;
+  bool dispatching_messages_ = false;
+  ConditionVariable incoming_message_cond_;
+  // Used from any thread
+  Agent* const agent_;
+  v8::Isolate* const isolate_;
+  v8::Platform* const platform_;
+  DeleteFnPtr<AsyncAndInterface, CloseAsync> main_thread_request_;
+  std::shared_ptr<MainThreadHandle> handle_;
+};
+
+}  // namespace inspector
+}  // namespace node
+#endif  // SRC_INSPECTOR_MAIN_THREAD_INTERFACE_H_
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 2b03fd05b115a3..ebb8d8a161606d 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -1,6 +1,7 @@
 #include "inspector_agent.h"
 
 #include "inspector_io.h"
+#include "inspector/main_thread_interface.h"
 #include "inspector/node_string.h"
 #include "inspector/tracing_agent.h"
 #include "node/inspector/protocol/Protocol.h"
@@ -49,7 +50,7 @@ class StartIoTask : public v8::Task {
   explicit StartIoTask(Agent* agent) : agent(agent) {}
 
   void Run() override {
-    agent->StartIoThread(false);
+    agent->StartIoThread();
   }
 
  private:
@@ -64,11 +65,11 @@ std::unique_ptr<StringBuffer> ToProtocolString(Isolate* isolate,
 
 // Called on the main thread.
 void StartIoThreadAsyncCallback(uv_async_t* handle) {
-  static_cast<Agent*>(handle->data)->StartIoThread(false);
+  static_cast<Agent*>(handle->data)->StartIoThread();
 }
 
 void StartIoInterrupt(Isolate* isolate, void* agent) {
-  static_cast<Agent*>(agent)->StartIoThread(false);
+  static_cast<Agent*>(agent)->StartIoThread();
 }
 
 
@@ -195,8 +196,10 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
  public:
   explicit ChannelImpl(Environment* env,
                        const std::unique_ptr<V8Inspector>& inspector,
-                       std::unique_ptr<InspectorSessionDelegate> delegate)
-                       : delegate_(std::move(delegate)) {
+                       std::unique_ptr<InspectorSessionDelegate> delegate,
+                       bool prevent_shutdown)
+                       : delegate_(std::move(delegate)),
+                         prevent_shutdown_(prevent_shutdown) {
     session_ = inspector->connect(1, this, StringView());
     node_dispatcher_.reset(new protocol::UberDispatcher(this));
     tracing_agent_.reset(new protocol::TracingAgent(env));
@@ -208,7 +211,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     tracing_agent_.reset();  // Dispose before the dispatchers
   }
 
-  void dispatchProtocolMessage(const StringView& message) {
+  std::string dispatchProtocolMessage(const StringView& message) {
     std::unique_ptr<protocol::DictionaryValue> parsed;
     std::string method;
     node_dispatcher_->getCommandName(
@@ -219,6 +222,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     } else {
       node_dispatcher_->dispatch(std::move(parsed));
     }
+    return method;
   }
 
   void schedulePauseOnNextStatement(const std::string& reason) {
@@ -226,6 +230,10 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     session_->schedulePauseOnNextStatement(buffer->string(), buffer->string());
   }
 
+  bool preventShutdown() {
+    return prevent_shutdown_;
+  }
+
  private:
   void sendResponse(
       int callId,
@@ -263,6 +271,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
   std::unique_ptr<protocol::UberDispatcher> node_dispatcher_;
+  bool prevent_shutdown_;
 };
 
 class InspectorTimer {
@@ -324,6 +333,44 @@ class InspectorTimerHandle {
  private:
   InspectorTimer* timer_;
 };
+
+class SameThreadInspectorSession : public InspectorSession {
+ public:
+  SameThreadInspectorSession(
+      int session_id, std::shared_ptr<NodeInspectorClient> client)
+      : session_id_(session_id), client_(client) {}
+  ~SameThreadInspectorSession() override;
+  void Dispatch(const v8_inspector::StringView& message) override;
+
+ private:
+  int session_id_;
+  std::weak_ptr<NodeInspectorClient> client_;
+};
+
+void NotifyClusterWorkersDebugEnabled(Environment* env) {
+  v8::Isolate* isolate = env->isolate();
+  HandleScope handle_scope(isolate);
+  auto context = env->context();
+
+  // Send message to enable debug in cluster workers
+  Local<Object> process_object = env->process_object();
+  Local<Value> emit_fn =
+      process_object->Get(context, FIXED_ONE_BYTE_STRING(isolate, "emit"))
+          .ToLocalChecked();
+  // In case the thread started early during the startup
+  if (!emit_fn->IsFunction())
+    return;
+
+  Local<Object> message = Object::New(isolate);
+  message->Set(context, FIXED_ONE_BYTE_STRING(isolate, "cmd"),
+               FIXED_ONE_BYTE_STRING(isolate, "NODE_DEBUG_ENABLED")).FromJust();
+  Local<Value> argv[] = {
+    FIXED_ONE_BYTE_STRING(isolate, "internalMessage"),
+    message
+  };
+  MakeCallback(env->isolate(), process_object, emit_fn.As<Function>(),
+               arraysize(argv), argv, {0, 0});
+}
 }  // namespace
 
 class NodeInspectorClient : public V8InspectorClient {
@@ -337,31 +384,18 @@ class NodeInspectorClient : public V8InspectorClient {
   }
 
   void runMessageLoopOnPause(int context_group_id) override {
-    runMessageLoop(false);
-  }
-
-  void runMessageLoop(bool ignore_terminated) {
-    if (running_nested_loop_)
-      return;
-    terminated_ = false;
-    running_nested_loop_ = true;
-    MultiIsolatePlatform* platform = env_->isolate_data()->platform();
-    while ((ignore_terminated || !terminated_) && waitForFrontendEvent()) {
-      while (platform->FlushForegroundTasks(env_->isolate())) {}
-    }
-    terminated_ = false;
-    running_nested_loop_ = false;
+    waiting_for_resume_ = true;
+    runMessageLoop();
   }
 
-  bool waitForFrontendEvent() {
-    InspectorIo* io = env_->inspector_agent()->io();
-    if (io == nullptr)
-      return false;
-    return io->WaitForFrontendEvent();
+  void waitForIoShutdown() {
+    waiting_for_io_shutdown_ = true;
+    runMessageLoop();
   }
 
-  double currentTimeMS() override {
-    return uv_hrtime() * 1.0 / NANOS_PER_MSEC;
+  void waitForFrontend() {
+    waiting_for_frontend_ = true;
+    runMessageLoop();
   }
 
   void maxAsyncCallStackDepthChanged(int depth) override {
@@ -398,16 +432,17 @@ class NodeInspectorClient : public V8InspectorClient {
   }
 
   void quitMessageLoopOnPause() override {
-    terminated_ = true;
+    waiting_for_resume_ = false;
   }
 
-  int connectFrontend(std::unique_ptr<InspectorSessionDelegate> delegate) {
+  int connectFrontend(std::unique_ptr<InspectorSessionDelegate> delegate,
+                      bool prevent_shutdown) {
     events_dispatched_ = true;
     int session_id = next_session_id_++;
     // TODO(addaleax): Revert back to using make_unique once we get issues
     // with CI resolved (i.e. revert the patch that added this comment).
     channels_[session_id].reset(
-        new ChannelImpl(env_, client_, std::move(delegate)));
+        new ChannelImpl(env_, client_, std::move(delegate), prevent_shutdown));
     return session_id;
   }
 
@@ -418,7 +453,10 @@ class NodeInspectorClient : public V8InspectorClient {
 
   void dispatchMessageFromFrontend(int session_id, const StringView& message) {
     events_dispatched_ = true;
-    channels_[session_id]->dispatchProtocolMessage(message);
+    std::string method =
+        channels_[session_id]->dispatchProtocolMessage(message);
+    if (waiting_for_frontend_)
+      waiting_for_frontend_ = method != "Runtime.runIfWaitingForDebugger";
   }
 
   Local<Context> ensureDefaultContextInGroup(int contextGroupId) override {
@@ -509,116 +547,150 @@ class NodeInspectorClient : public V8InspectorClient {
   }
 
   bool hasConnectedSessions() {
+    for (const auto& id_channel : channels_) {
+      // Other sessions are "invisible" more most purposes
+      if (id_channel.second->preventShutdown())
+        return true;
+    }
+    return false;
+  }
+
+  std::shared_ptr<MainThreadHandle> getThreadHandle() {
+    if (interface_ == nullptr) {
+      interface_.reset(new MainThreadInterface(
+          env_->inspector_agent(), env_->event_loop(), env_->isolate(),
+          env_->isolate_data()->platform()));
+    }
+    return interface_->GetHandle();
+  }
+
+  bool IsActive() {
     return !channels_.empty();
   }
 
  private:
+  bool shouldRunMessageLoop() {
+    if (waiting_for_frontend_)
+      return true;
+    if (waiting_for_io_shutdown_ || waiting_for_resume_)
+      return hasConnectedSessions();
+    return false;
+  }
+
+  void runMessageLoop() {
+    if (running_nested_loop_)
+      return;
+
+    running_nested_loop_ = true;
+
+    MultiIsolatePlatform* platform = env_->isolate_data()->platform();
+    while (shouldRunMessageLoop()) {
+      if (interface_ && hasConnectedSessions())
+        interface_->WaitForFrontendEvent();
+      while (platform->FlushForegroundTasks(env_->isolate())) {}
+    }
+    running_nested_loop_ = false;
+  }
+
+  double currentTimeMS() override {
+    return uv_hrtime() * 1.0 / NANOS_PER_MSEC;
+  }
+
   node::Environment* env_;
-  bool terminated_ = false;
   bool running_nested_loop_ = false;
   std::unique_ptr<V8Inspector> client_;
   std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_;
   std::unordered_map<void*, InspectorTimerHandle> timers_;
   int next_session_id_ = 1;
   bool events_dispatched_ = false;
+  bool waiting_for_resume_ = false;
+  bool waiting_for_frontend_ = false;
+  bool waiting_for_io_shutdown_ = false;
+  // Allows accessing Inspector from non-main threads
+  std::unique_ptr<MainThreadInterface> interface_;
 };
 
 Agent::Agent(Environment* env) : parent_env_(env) {}
 
-// Destructor needs to be defined here in implementation file as the header
-// does not have full definition of some classes.
-Agent::~Agent() {
-}
+Agent::~Agent() = default;
 
-bool Agent::Start(const char* path, const DebugOptions& options) {
-  path_ = path == nullptr ? "" : path;
+bool Agent::Start(const std::string& path, const DebugOptions& options) {
+  path_ = path;
   debug_options_ = options;
   client_ = std::make_shared<NodeInspectorClient>(parent_env_);
-  CHECK_EQ(0, uv_async_init(uv_default_loop(),
-                            &start_io_thread_async,
-                            StartIoThreadAsyncCallback));
-  start_io_thread_async.data = this;
-  uv_unref(reinterpret_cast<uv_handle_t*>(&start_io_thread_async));
-
-  // Ignore failure, SIGUSR1 won't work, but that should not block node start.
-  StartDebugSignalHandler();
-  if (options.inspector_enabled()) {
-    // This will return false if listen failed on the inspector port.
-    return StartIoThread(options.wait_for_connect());
+  if (parent_env_->is_main_thread()) {
+    CHECK_EQ(0, uv_async_init(parent_env_->event_loop(),
+                              &start_io_thread_async,
+                              StartIoThreadAsyncCallback));
+    uv_unref(reinterpret_cast<uv_handle_t*>(&start_io_thread_async));
+    start_io_thread_async.data = this;
+    // Ignore failure, SIGUSR1 won't work, but that should not block node start.
+    StartDebugSignalHandler();
+  }
+
+  bool wait_for_connect = options.wait_for_connect();
+  if (!options.inspector_enabled() || !StartIoThread()) {
+    return false;
+  }
+  if (wait_for_connect) {
+    HandleScope scope(parent_env_->isolate());
+    parent_env_->process_object()->DefineOwnProperty(
+        parent_env_->context(),
+        FIXED_ONE_BYTE_STRING(parent_env_->isolate(), "_breakFirstLine"),
+        True(parent_env_->isolate()),
+        static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum))
+        .FromJust();
+    client_->waitForFrontend();
   }
   return true;
 }
 
-bool Agent::StartIoThread(bool wait_for_connect) {
+bool Agent::StartIoThread() {
   if (io_ != nullptr)
     return true;
 
   CHECK_NOT_NULL(client_);
 
-  io_ = std::unique_ptr<InspectorIo>(
-      new InspectorIo(parent_env_, path_, debug_options_, wait_for_connect));
-  if (!io_->Start()) {
-    client_.reset();
+  io_ = InspectorIo::Start(
+      client_->getThreadHandle(), path_, debug_options_);
+  if (io_ == nullptr) {
     return false;
   }
-
-  v8::Isolate* isolate = parent_env_->isolate();
-  HandleScope handle_scope(isolate);
-  auto context = parent_env_->context();
-
-  // Send message to enable debug in workers
-  Local<Object> process_object = parent_env_->process_object();
-  Local<Value> emit_fn =
-      process_object->Get(context, FIXED_ONE_BYTE_STRING(isolate, "emit"))
-          .ToLocalChecked();
-  // In case the thread started early during the startup
-  if (!emit_fn->IsFunction())
-    return true;
-
-  Local<Object> message = Object::New(isolate);
-  message->Set(context, FIXED_ONE_BYTE_STRING(isolate, "cmd"),
-               FIXED_ONE_BYTE_STRING(isolate, "NODE_DEBUG_ENABLED")).FromJust();
-  Local<Value> argv[] = {
-    FIXED_ONE_BYTE_STRING(isolate, "internalMessage"),
-    message
-  };
-  MakeCallback(parent_env_->isolate(), process_object, emit_fn.As<Function>(),
-               arraysize(argv), argv, {0, 0});
-
+  NotifyClusterWorkersDebugEnabled(parent_env_);
   return true;
 }
 
 void Agent::Stop() {
-  if (io_ != nullptr) {
-    io_->Stop();
-    io_.reset();
-  }
+  io_.reset();
 }
 
 std::unique_ptr<InspectorSession> Agent::Connect(
-    std::unique_ptr<InspectorSessionDelegate> delegate) {
-  int session_id = client_->connectFrontend(std::move(delegate));
+    std::unique_ptr<InspectorSessionDelegate> delegate,
+    bool prevent_shutdown) {
+  CHECK_NOT_NULL(client_);
+  int session_id = client_->connectFrontend(std::move(delegate),
+                                            prevent_shutdown);
   return std::unique_ptr<InspectorSession>(
-      new InspectorSession(session_id, client_));
+      new SameThreadInspectorSession(session_id, client_));
 }
 
 void Agent::WaitForDisconnect() {
   CHECK_NOT_NULL(client_);
+  if (client_->hasConnectedSessions()) {
+    fprintf(stderr, "Waiting for the debugger to disconnect...\n");
+    fflush(stderr);
+  }
   // TODO(addaleax): Maybe this should use an at-exit hook for the Environment
   // or something similar?
   client_->contextDestroyed(parent_env_->context());
   if (io_ != nullptr) {
-    io_->WaitForDisconnect();
-    // There is a bug in V8 Inspector (https://crbug.com/834056) that
-    // calls V8InspectorClient::quitMessageLoopOnPause when a session
-    // disconnects. We are using this flag to ignore those calls so the message
-    // loop is spinning as long as there's a reason to expect inspector messages
-    client_->runMessageLoop(true);
+    io_->StopAcceptingNewConnections();
+    client_->waitForIoShutdown();
   }
 }
 
 void Agent::FatalException(Local<Value> error, Local<v8::Message> message) {
-  if (!IsStarted())
+  if (!IsListening())
     return;
   client_->FatalException(error, message);
   WaitForDisconnect();
@@ -718,26 +790,35 @@ void Agent::ContextCreated(Local<Context> context, const ContextInfo& info) {
   client_->contextCreated(context, info);
 }
 
-bool Agent::IsWaitingForConnect() {
+bool Agent::WillWaitForConnect() {
   return debug_options_.wait_for_connect();
 }
 
-bool Agent::HasConnectedSessions() {
+bool Agent::IsActive() {
   if (client_ == nullptr)
     return false;
-  return client_->hasConnectedSessions();
+  return io_ != nullptr || client_->IsActive();
 }
 
-InspectorSession::InspectorSession(int session_id,
-                                   std::shared_ptr<NodeInspectorClient> client)
-                                   : session_id_(session_id), client_(client) {}
+void Agent::WaitForConnect() {
+  CHECK_NOT_NULL(client_);
+  client_->waitForFrontend();
+}
 
-InspectorSession::~InspectorSession() {
-  client_->disconnectFrontend(session_id_);
+SameThreadInspectorSession::~SameThreadInspectorSession() {
+  auto client = client_.lock();
+  if (client)
+    client->disconnectFrontend(session_id_);
 }
 
-void InspectorSession::Dispatch(const StringView& message) {
-  client_->dispatchMessageFromFrontend(session_id_, message);
+void SameThreadInspectorSession::Dispatch(
+    const v8_inspector::StringView& message) {
+  auto client = client_.lock();
+  if (client)
+    client->dispatchMessageFromFrontend(session_id_, message);
 }
+
+
+
 }  // namespace inspector
 }  // namespace node
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index 7295d048b64357..dcd6e13aba275f 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -20,7 +20,6 @@ class StringView;
 namespace node {
 // Forward declaration to break recursive dependency chain with src/env.h.
 class Environment;
-class NodePlatform;
 struct ContextInfo;
 
 namespace inspector {
@@ -29,12 +28,8 @@ class NodeInspectorClient;
 
 class InspectorSession {
  public:
-  InspectorSession(int session_id, std::shared_ptr<NodeInspectorClient> client);
-  ~InspectorSession();
-  void Dispatch(const v8_inspector::StringView& message);
- private:
-  int session_id_;
-  std::shared_ptr<NodeInspectorClient> client_;
+  virtual ~InspectorSession() {}
+  virtual void Dispatch(const v8_inspector::StringView& message) = 0;
 };
 
 class InspectorSessionDelegate {
@@ -50,15 +45,21 @@ class Agent {
   ~Agent();
 
   // Create client_, may create io_ if option enabled
-  bool Start(const char* path, const DebugOptions& options);
+  bool Start(const std::string& path, const DebugOptions& options);
   // Stop and destroy io_
   void Stop();
 
-  bool IsStarted() { return !!client_; }
-
-  // IO thread started, and client connected
-  bool IsWaitingForConnect();
-
+  bool IsListening() { return io_ != nullptr; }
+  // Returns true if the Node inspector is actually in use. It will be true
+  // if either the user explicitely opted into inspector (e.g. with the
+  // --inspect command line flag) or if inspector JS API had been used.
+  bool IsActive();
+
+  // Option is set to wait for session connection
+  bool WillWaitForConnect();
+  // Blocks till frontend connects and sends "runIfWaitingForDebugger"
+  void WaitForConnect();
+  // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
   void WaitForDisconnect();
   void FatalException(v8::Local<v8::Value> error,
                       v8::Local<v8::Message> message);
@@ -77,22 +78,20 @@ class Agent {
   void EnableAsyncHook();
   void DisableAsyncHook();
 
-  // Called by the WS protocol and JS binding to create inspector sessions.
+  // Called to create inspector sessions that can be used from the main thread.
   // The inspector responds by using the delegate to send messages back.
   std::unique_ptr<InspectorSession> Connect(
-      std::unique_ptr<InspectorSessionDelegate> delegate);
+      std::unique_ptr<InspectorSessionDelegate> delegate,
+      bool prevent_shutdown);
 
   void PauseOnNextJavascriptStatement(const std::string& reason);
 
-  // Returns true as long as there is at least one connected session.
-  bool HasConnectedSessions();
-
   InspectorIo* io() {
     return io_.get();
   }
 
   // Can only be called from the main thread.
-  bool StartIoThread(bool wait_for_connect);
+  bool StartIoThread();
 
   // Calls StartIoThread() from off the main thread.
   void RequestIoThreadStart();
@@ -105,7 +104,9 @@ class Agent {
                        const node::Persistent<v8::Function>& fn);
 
   node::Environment* parent_env_;
+  // Encapsulates majority of the Inspector functionality
   std::shared_ptr<NodeInspectorClient> client_;
+  // Interface for transports, e.g. WebSocket server
   std::unique_ptr<InspectorIo> io_;
   std::string path_;
   DebugOptions debug_options_;
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
index 78ecce7398bd59..41fea546a83265 100644
--- a/src/inspector_io.cc
+++ b/src/inspector_io.cc
@@ -1,6 +1,7 @@
 #include "inspector_io.h"
 
 #include "inspector_socket_server.h"
+#include "inspector/main_thread_interface.h"
 #include "inspector/node_string.h"
 #include "env-inl.h"
 #include "debug_utils.h"
@@ -11,23 +12,16 @@
 #include "util.h"
 #include "zlib.h"
 
-#include <sstream>
-#include <unicode/unistr.h>
-
+#include <deque>
 #include <string.h>
 #include <vector>
 
-
 namespace node {
 namespace inspector {
 namespace {
-using AsyncAndAgent = std::pair<uv_async_t, Agent*>;
 using v8_inspector::StringBuffer;
 using v8_inspector::StringView;
 
-template <typename Transport>
-using TransportAndIo = std::pair<Transport*, InspectorIo*>;
-
 std::string ScriptPath(uv_loop_t* loop, const std::string& script_name) {
   std::string script_path;
 
@@ -64,45 +58,151 @@ std::string GenerateID() {
   return uuid;
 }
 
-void HandleSyncCloseCb(uv_handle_t* handle) {
-  *static_cast<bool*>(handle->data) = true;
-}
+class RequestToServer {
+ public:
+  RequestToServer(TransportAction action,
+                  int session_id,
+                  std::unique_ptr<v8_inspector::StringBuffer> message)
+                  : action_(action),
+                    session_id_(session_id),
+                    message_(std::move(message)) {}
+
+  void Dispatch(InspectorSocketServer* server) const {
+    switch (action_) {
+      case TransportAction::kKill:
+        server->TerminateConnections();
+        // Fallthrough
+      case TransportAction::kStop:
+        server->Stop();
+        break;
+      case TransportAction::kSendMessage:
+        server->Send(
+            session_id_,
+            protocol::StringUtil::StringViewToUtf8(message_->string()));
+        break;
+    }
+  }
 
-void CloseAsyncAndLoop(uv_async_t* async) {
-  bool is_closed = false;
-  async->data = &is_closed;
-  uv_close(reinterpret_cast<uv_handle_t*>(async), HandleSyncCloseCb);
-  while (!is_closed)
-    uv_run(async->loop, UV_RUN_ONCE);
-  async->data = nullptr;
-  CheckedUvLoopClose(async->loop);
-}
+ private:
+  TransportAction action_;
+  int session_id_;
+  std::unique_ptr<v8_inspector::StringBuffer> message_;
+};
 
-// Delete main_thread_req_ on async handle close
-void ReleasePairOnAsyncClose(uv_handle_t* async) {
-  std::unique_ptr<AsyncAndAgent> pair(node::ContainerOf(&AsyncAndAgent::first,
-      reinterpret_cast<uv_async_t*>(async)));
-  // Unique_ptr goes out of scope here and pointer is deleted.
-}
+class RequestQueueData {
+ public:
+  using MessageQueue = std::deque<RequestToServer>;
+
+  explicit RequestQueueData(uv_loop_t* loop)
+                            : handle_(std::make_shared<RequestQueue>(this)) {
+    int err = uv_async_init(loop, &async_, [](uv_async_t* async) {
+      RequestQueueData* wrapper =
+          node::ContainerOf(&RequestQueueData::async_, async);
+      wrapper->DoDispatch();
+    });
+    CHECK_EQ(0, err);
+  }
+
+  static void CloseAndFree(RequestQueueData* queue);
+
+  void Post(int session_id,
+            TransportAction action,
+            std::unique_ptr<StringBuffer> message) {
+    Mutex::ScopedLock scoped_lock(state_lock_);
+    bool notify = messages_.empty();
+    messages_.emplace_back(action, session_id, std::move(message));
+    if (notify) {
+      CHECK_EQ(0, uv_async_send(&async_));
+      incoming_message_cond_.Broadcast(scoped_lock);
+    }
+  }
+
+  void Wait() {
+    Mutex::ScopedLock scoped_lock(state_lock_);
+    if (messages_.empty()) {
+      incoming_message_cond_.Wait(scoped_lock);
+    }
+  }
+
+  void SetServer(InspectorSocketServer* server) {
+    server_ = server;
+  }
 
+  std::shared_ptr<RequestQueue> handle() {
+    return handle_;
+  }
+
+ private:
+  ~RequestQueueData() = default;
+
+  MessageQueue GetMessages() {
+    Mutex::ScopedLock scoped_lock(state_lock_);
+    MessageQueue messages;
+    messages_.swap(messages);
+    return messages;
+  }
+
+  void DoDispatch() {
+    if (server_ == nullptr)
+      return;
+    for (const auto& request : GetMessages()) {
+      request.Dispatch(server_);
+    }
+  }
+
+  std::shared_ptr<RequestQueue> handle_;
+  uv_async_t async_;
+  InspectorSocketServer* server_ = nullptr;
+  MessageQueue messages_;
+  Mutex state_lock_;  // Locked before mutating the queue.
+  ConditionVariable incoming_message_cond_;
+};
 }  // namespace
 
-std::unique_ptr<StringBuffer> Utf8ToStringView(const std::string& message) {
-  icu::UnicodeString utf16 =
-    icu::UnicodeString::fromUTF8(icu::StringPiece(message.data(),
-      message.length()));
-  StringView view(reinterpret_cast<const uint16_t*>(utf16.getBuffer()),
-                  utf16.length());
-  return StringBuffer::create(view);
-}
+class RequestQueue {
+ public:
+  explicit RequestQueue(RequestQueueData* data) : data_(data) {}
+
+  void Reset() {
+    Mutex::ScopedLock scoped_lock(lock_);
+    data_ = nullptr;
+  }
 
+  void Post(int session_id,
+            TransportAction action,
+            std::unique_ptr<StringBuffer> message) {
+    Mutex::ScopedLock scoped_lock(lock_);
+    if (data_ != nullptr)
+      data_->Post(session_id, action, std::move(message));
+  }
+
+  void SetServer(InspectorSocketServer* server) {
+    Mutex::ScopedLock scoped_lock(lock_);
+    if (data_ != nullptr)
+      data_->SetServer(server);
+  }
+
+  bool Expired() {
+    Mutex::ScopedLock scoped_lock(lock_);
+    return data_ == nullptr;
+  }
+
+ private:
+  RequestQueueData* data_;
+  Mutex lock_;
+};
 
 class IoSessionDelegate : public InspectorSessionDelegate {
  public:
-  explicit IoSessionDelegate(InspectorIo* io, int id) : io_(io), id_(id) { }
-  void SendMessageToFrontend(const v8_inspector::StringView& message) override;
+  explicit IoSessionDelegate(std::shared_ptr<RequestQueue> queue, int id)
+                             : request_queue_(queue), id_(id) { }
+  void SendMessageToFrontend(const v8_inspector::StringView& message) override {
+    request_queue_->Post(id_, TransportAction::kSendMessage,
+                         StringBuffer::create(message));
+  }
+
  private:
-  InspectorIo* io_;
+  std::shared_ptr<RequestQueue> request_queue_;
   int id_;
 };
 
@@ -110,361 +210,133 @@ class IoSessionDelegate : public InspectorSessionDelegate {
 // mostly session start, message received, and session end.
 class InspectorIoDelegate: public node::inspector::SocketServerDelegate {
  public:
-  InspectorIoDelegate(InspectorIo* io, const std::string& target_id,
+  InspectorIoDelegate(std::shared_ptr<RequestQueueData> queue,
+                      std::shared_ptr<MainThreadHandle> main_threade,
+                      const std::string& target_id,
                       const std::string& script_path,
-                      const std::string& script_name, bool wait);
+                      const std::string& script_name);
   ~InspectorIoDelegate() {
-    io_->ServerDone();
   }
-  // Calls PostIncomingMessage() with appropriate InspectorAction:
-  //   kStartSession
+
   void StartSession(int session_id, const std::string& target_id) override;
-  //   kSendMessage
   void MessageReceived(int session_id, const std::string& message) override;
-  //   kEndSession
   void EndSession(int session_id) override;
 
   std::vector<std::string> GetTargetIds() override;
   std::string GetTargetTitle(const std::string& id) override;
   std::string GetTargetUrl(const std::string& id) override;
-
   void AssignServer(InspectorSocketServer* server) override {
-    server_ = server;
+    request_queue_->SetServer(server);
   }
 
  private:
-  InspectorIo* io_;
-  int session_id_;
+  std::shared_ptr<RequestQueueData> request_queue_;
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  std::unordered_map<int, std::unique_ptr<InspectorSession>> sessions_;
   const std::string script_name_;
   const std::string script_path_;
   const std::string target_id_;
-  bool waiting_;
-  InspectorSocketServer* server_;
 };
 
-void InterruptCallback(v8::Isolate*, void* agent) {
-  InspectorIo* io = static_cast<Agent*>(agent)->io();
-  if (io != nullptr)
-    io->DispatchMessages();
-}
-
-class DispatchMessagesTask : public v8::Task {
- public:
-  explicit DispatchMessagesTask(Agent* agent) : agent_(agent) {}
-
-  void Run() override {
-    InspectorIo* io = agent_->io();
-    if (io != nullptr)
-      io->DispatchMessages();
+// static
+std::unique_ptr<InspectorIo> InspectorIo::Start(
+    std::shared_ptr<MainThreadHandle> main_thread,
+    const std::string& path,
+    const DebugOptions& options) {
+  auto io = std::unique_ptr<InspectorIo>(
+      new InspectorIo(main_thread, path, options));
+  if (io->request_queue_->Expired()) {  // Thread is not running
+    return nullptr;
   }
-
- private:
-  Agent* agent_;
-};
-
-InspectorIo::InspectorIo(Environment* env, const std::string& path,
-                         const DebugOptions& options, bool wait_for_connect)
-                         : options_(options), thread_(), state_(State::kNew),
-                           parent_env_(env), thread_req_(),
-                           platform_(parent_env_->isolate_data()->platform()),
-                           dispatching_messages_(false), script_name_(path),
-                           wait_for_connect_(wait_for_connect), port_(-1),
-                           id_(GenerateID()) {
-  main_thread_req_ = new AsyncAndAgent({uv_async_t(), env->inspector_agent()});
-  CHECK_EQ(0, uv_async_init(env->event_loop(), &main_thread_req_->first,
-                            InspectorIo::MainThreadReqAsyncCb));
-  uv_unref(reinterpret_cast<uv_handle_t*>(&main_thread_req_->first));
-  CHECK_EQ(0, uv_sem_init(&thread_start_sem_, 0));
+  return io;
 }
 
-InspectorIo::~InspectorIo() {
-  uv_sem_destroy(&thread_start_sem_);
-  uv_close(reinterpret_cast<uv_handle_t*>(&main_thread_req_->first),
-           ReleasePairOnAsyncClose);
-}
-
-bool InspectorIo::Start() {
-  CHECK_EQ(state_, State::kNew);
+InspectorIo::InspectorIo(std::shared_ptr<MainThreadHandle> main_thread,
+                         const std::string& path,
+                         const DebugOptions& options)
+                         : main_thread_(main_thread), options_(options),
+                           thread_(), script_name_(path), id_(GenerateID()) {
+  Mutex::ScopedLock scoped_lock(thread_start_lock_);
   CHECK_EQ(uv_thread_create(&thread_, InspectorIo::ThreadMain, this), 0);
-  uv_sem_wait(&thread_start_sem_);
-
-  if (state_ == State::kError) {
-    return false;
-  }
-  state_ = State::kAccepting;
-  if (wait_for_connect_) {
-    DispatchMessages();
-  }
-  return true;
+  thread_start_condition_.Wait(scoped_lock);
 }
 
-void InspectorIo::Stop() {
-  CHECK_IMPLIES(sessions_.empty(), state_ == State::kAccepting);
-  Write(TransportAction::kKill, 0, StringView());
+InspectorIo::~InspectorIo() {
+  request_queue_->Post(0, TransportAction::kKill, nullptr);
   int err = uv_thread_join(&thread_);
   CHECK_EQ(err, 0);
-  state_ = State::kShutDown;
-  DispatchMessages();
 }
 
-bool InspectorIo::IsStarted() {
-  return platform_ != nullptr;
-}
-
-void InspectorIo::WaitForDisconnect() {
-  if (state_ == State::kAccepting)
-    state_ = State::kDone;
-  if (!sessions_.empty()) {
-    state_ = State::kShutDown;
-    Write(TransportAction::kStop, 0, StringView());
-    fprintf(stderr, "Waiting for the debugger to disconnect...\n");
-    fflush(stderr);
-  }
+void InspectorIo::StopAcceptingNewConnections() {
+  request_queue_->Post(0, TransportAction::kStop, nullptr);
 }
 
 // static
 void InspectorIo::ThreadMain(void* io) {
-  static_cast<InspectorIo*>(io)->ThreadMain<InspectorSocketServer>();
-}
-
-// static
-template <typename Transport>
-void InspectorIo::IoThreadAsyncCb(uv_async_t* async) {
-  TransportAndIo<Transport>* transport_and_io =
-      static_cast<TransportAndIo<Transport>*>(async->data);
-  if (transport_and_io == nullptr) {
-    return;
-  }
-  Transport* transport = transport_and_io->first;
-  InspectorIo* io = transport_and_io->second;
-  MessageQueue<TransportAction> outgoing_message_queue;
-  io->SwapBehindLock(&io->outgoing_message_queue_, &outgoing_message_queue);
-  for (const auto& outgoing : outgoing_message_queue) {
-    int session_id = std::get<1>(outgoing);
-    switch (std::get<0>(outgoing)) {
-    case TransportAction::kKill:
-      transport->TerminateConnections();
-      // Fallthrough
-    case TransportAction::kStop:
-      transport->Stop();
-      break;
-    case TransportAction::kSendMessage:
-      transport->Send(session_id,
-                      protocol::StringUtil::StringViewToUtf8(
-                          std::get<2>(outgoing)->string()));
-      break;
-    case TransportAction::kAcceptSession:
-      transport->AcceptSession(session_id);
-      break;
-    case TransportAction::kDeclineSession:
-      transport->DeclineSession(session_id);
-      break;
-    }
-  }
+  static_cast<InspectorIo*>(io)->ThreadMain();
 }
 
-template <typename Transport>
 void InspectorIo::ThreadMain() {
   uv_loop_t loop;
   loop.data = nullptr;
   int err = uv_loop_init(&loop);
   CHECK_EQ(err, 0);
-  thread_req_.data = nullptr;
-  err = uv_async_init(&loop, &thread_req_, IoThreadAsyncCb<Transport>);
-  CHECK_EQ(err, 0);
+  std::shared_ptr<RequestQueueData> queue(new RequestQueueData(&loop),
+                                          RequestQueueData::CloseAndFree);
   std::string script_path = ScriptPath(&loop, script_name_);
-  auto delegate = std::unique_ptr<InspectorIoDelegate>(
-      new InspectorIoDelegate(this, id_, script_path, script_name_,
-                              wait_for_connect_));
-  Transport server(std::move(delegate), &loop, options_.host_name(),
-                   options_.port());
-  TransportAndIo<Transport> queue_transport(&server, this);
-  thread_req_.data = &queue_transport;
-  if (!server.Start()) {
-    state_ = State::kError;  // Safe, main thread is waiting on semaphore
-    CloseAsyncAndLoop(&thread_req_);
-    uv_sem_post(&thread_start_sem_);
-    return;
-  }
-  port_ = server.Port();  // Safe, main thread is waiting on semaphore.
-  if (!wait_for_connect_) {
-    uv_sem_post(&thread_start_sem_);
+  std::unique_ptr<InspectorIoDelegate> delegate(
+      new InspectorIoDelegate(queue, main_thread_, id_,
+                              script_path, script_name_));
+  InspectorSocketServer server(std::move(delegate), &loop,
+                               options_.host_name(), options_.port());
+  request_queue_ = queue->handle();
+  // Its lifetime is now that of the server delegate
+  queue.reset();
+  {
+    Mutex::ScopedLock scoped_lock(thread_start_lock_);
+    if (server.Start()) {
+      port_ = server.Port();
+    }
+    thread_start_condition_.Broadcast(scoped_lock);
   }
   uv_run(&loop, UV_RUN_DEFAULT);
-  thread_req_.data = nullptr;
   CheckedUvLoopClose(&loop);
 }
 
-template <typename ActionType>
-bool InspectorIo::AppendMessage(MessageQueue<ActionType>* queue,
-                                ActionType action, int session_id,
-                                std::unique_ptr<StringBuffer> buffer) {
-  Mutex::ScopedLock scoped_lock(state_lock_);
-  bool trigger_pumping = queue->empty();
-  queue->push_back(std::make_tuple(action, session_id, std::move(buffer)));
-  return trigger_pumping;
-}
-
-template <typename ActionType>
-void InspectorIo::SwapBehindLock(MessageQueue<ActionType>* vector1,
-                                 MessageQueue<ActionType>* vector2) {
-  Mutex::ScopedLock scoped_lock(state_lock_);
-  vector1->swap(*vector2);
-}
-
-void InspectorIo::PostIncomingMessage(InspectorAction action, int session_id,
-                                      const std::string& message) {
-  Debug(parent_env_, DebugCategory::INSPECTOR_SERVER,
-        ">>> %s\n", message.c_str());
-  if (AppendMessage(&incoming_message_queue_, action, session_id,
-                    Utf8ToStringView(message))) {
-    Agent* agent = main_thread_req_->second;
-    v8::Isolate* isolate = parent_env_->isolate();
-    platform_->CallOnForegroundThread(isolate,
-                                      new DispatchMessagesTask(agent));
-    isolate->RequestInterrupt(InterruptCallback, agent);
-    CHECK_EQ(0, uv_async_send(&main_thread_req_->first));
-  }
-  Mutex::ScopedLock scoped_lock(state_lock_);
-  incoming_message_cond_.Broadcast(scoped_lock);
-}
-
 std::vector<std::string> InspectorIo::GetTargetIds() const {
   return { id_ };
 }
 
-TransportAction InspectorIo::Attach(int session_id) {
-  Agent* agent = parent_env_->inspector_agent();
-  fprintf(stderr, "Debugger attached.\n");
-  sessions_[session_id] = agent->Connect(std::unique_ptr<IoSessionDelegate>(
-      new IoSessionDelegate(this, session_id)));
-  return TransportAction::kAcceptSession;
-}
-
-void InspectorIo::DispatchMessages() {
-  if (dispatching_messages_)
-    return;
-  dispatching_messages_ = true;
-  bool had_messages = false;
-  do {
-    if (dispatching_message_queue_.empty())
-      SwapBehindLock(&incoming_message_queue_, &dispatching_message_queue_);
-    had_messages = !dispatching_message_queue_.empty();
-    while (!dispatching_message_queue_.empty()) {
-      MessageQueue<InspectorAction>::value_type task;
-      std::swap(dispatching_message_queue_.front(), task);
-      dispatching_message_queue_.pop_front();
-      int id = std::get<1>(task);
-      StringView message = std::get<2>(task)->string();
-      switch (std::get<0>(task)) {
-      case InspectorAction::kStartSession:
-        Write(Attach(id), id, StringView());
-        break;
-      case InspectorAction::kStartSessionUnconditionally:
-        Attach(id);
-        break;
-      case InspectorAction::kEndSession:
-        sessions_.erase(id);
-        if (!sessions_.empty())
-          continue;
-        if (state_ == State::kShutDown) {
-          state_ = State::kDone;
-        } else {
-          state_ = State::kAccepting;
-        }
-        break;
-      case InspectorAction::kSendMessage:
-        auto session = sessions_.find(id);
-        if (session != sessions_.end() && session->second) {
-          session->second->Dispatch(message);
-        }
-        break;
-      }
-    }
-  } while (had_messages);
-  dispatching_messages_ = false;
-}
-
-// static
-void InspectorIo::MainThreadReqAsyncCb(uv_async_t* req) {
-  AsyncAndAgent* pair = node::ContainerOf(&AsyncAndAgent::first, req);
-  // Note that this may be called after io was closed or even after a new
-  // one was created and ran.
-  InspectorIo* io = pair->second->io();
-  if (io != nullptr)
-    io->DispatchMessages();
-}
-
-void InspectorIo::Write(TransportAction action, int session_id,
-                        const StringView& inspector_message) {
-  std::string message_str =
-      protocol::StringUtil::StringViewToUtf8(inspector_message);
-  Debug(parent_env_, DebugCategory::INSPECTOR_SERVER,
-        "<<< %s\n", message_str.c_str());
-  AppendMessage(&outgoing_message_queue_, action, session_id,
-                StringBuffer::create(inspector_message));
-  int err = uv_async_send(&thread_req_);
-  CHECK_EQ(0, err);
-}
-
-bool InspectorIo::WaitForFrontendEvent() {
-  // We allow DispatchMessages reentry as we enter the pause. This is important
-  // to support debugging the code invoked by an inspector call, such
-  // as Runtime.evaluate
-  dispatching_messages_ = false;
-  Mutex::ScopedLock scoped_lock(state_lock_);
-  if (sessions_.empty())
-    return false;
-  if (dispatching_message_queue_.empty() && incoming_message_queue_.empty()) {
-    incoming_message_cond_.Wait(scoped_lock);
-  }
-  return true;
-}
-
-InspectorIoDelegate::InspectorIoDelegate(InspectorIo* io,
-                                         const std::string& target_id,
-                                         const std::string& script_path,
-                                         const std::string& script_name,
-                                         bool wait)
-                                         : io_(io),
-                                           session_id_(0),
-                                           script_name_(script_name),
-                                           script_path_(script_path),
-                                           target_id_(target_id),
-                                           waiting_(wait),
-                                           server_(nullptr) { }
-
+InspectorIoDelegate::InspectorIoDelegate(
+    std::shared_ptr<RequestQueueData> queue,
+    std::shared_ptr<MainThreadHandle> main_thread,
+    const std::string& target_id,
+    const std::string& script_path,
+    const std::string& script_name)
+    : request_queue_(queue), main_thread_(main_thread),
+      script_name_(script_name), script_path_(script_path),
+      target_id_(target_id) {}
 
 void InspectorIoDelegate::StartSession(int session_id,
                                        const std::string& target_id) {
-  session_id_ = session_id;
-  InspectorAction action = InspectorAction::kStartSession;
-  if (waiting_) {
-    action = InspectorAction::kStartSessionUnconditionally;
-    server_->AcceptSession(session_id);
+  auto session = main_thread_->Connect(
+      std::unique_ptr<InspectorSessionDelegate>(
+          new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+  if (session) {
+    sessions_[session_id] = std::move(session);
+    fprintf(stderr, "Debugger attached.\n");
   }
-  io_->PostIncomingMessage(action, session_id, "");
 }
 
 void InspectorIoDelegate::MessageReceived(int session_id,
                                           const std::string& message) {
-  // TODO(pfeldman): Instead of blocking execution while debugger
-  // engages, node should wait for the run callback from the remote client
-  // and initiate its startup. This is a change to node.cc that should be
-  // upstreamed separately.
-  if (waiting_) {
-    if (message.find("\"Runtime.runIfWaitingForDebugger\"") !=
-        std::string::npos) {
-      waiting_ = false;
-      io_->ResumeStartup();
-    }
-  }
-  io_->PostIncomingMessage(InspectorAction::kSendMessage, session_id,
-                           message);
+  auto session = sessions_.find(session_id);
+  if (session != sessions_.end())
+    session->second->Dispatch(Utf8ToStringView(message)->string());
 }
 
 void InspectorIoDelegate::EndSession(int session_id) {
-  io_->PostIncomingMessage(InspectorAction::kEndSession, session_id, "");
+  sessions_.erase(session_id);
 }
 
 std::vector<std::string> InspectorIoDelegate::GetTargetIds() {
@@ -479,10 +351,17 @@ std::string InspectorIoDelegate::GetTargetUrl(const std::string& id) {
   return "file://" + script_path_;
 }
 
-void IoSessionDelegate::SendMessageToFrontend(
-    const v8_inspector::StringView& message) {
-  io_->Write(TransportAction::kSendMessage, id_, message);
+// static
+void RequestQueueData::CloseAndFree(RequestQueueData* queue) {
+  queue->handle_->Reset();
+  queue->handle_.reset();
+  uv_close(reinterpret_cast<uv_handle_t*>(&queue->async_),
+           [](uv_handle_t* handle) {
+    uv_async_t* async = reinterpret_cast<uv_async_t*>(handle);
+    RequestQueueData* wrapper =
+        node::ContainerOf(&RequestQueueData::async_, async);
+    delete wrapper;
+  });
 }
-
 }  // namespace inspector
 }  // namespace node
diff --git a/src/inspector_io.h b/src/inspector_io.h
index c897a44a528ec2..7c43d212f0422e 100644
--- a/src/inspector_io.h
+++ b/src/inspector_io.h
@@ -6,8 +6,6 @@
 #include "node_mutex.h"
 #include "uv.h"
 
-#include <deque>
-#include <unordered_map>
 #include <memory>
 #include <stddef.h>
 
@@ -16,17 +14,14 @@
 #endif
 
 
-// Forward declaration to break recursive dependency chain with src/env.h.
-namespace node {
-class Environment;
-}  // namespace node
-
 namespace v8_inspector {
 class StringBuffer;
 class StringView;
 }  // namespace v8_inspector
 
 namespace node {
+// Forward declaration to break recursive dependency chain with src/env.h.
+class Environment;
 namespace inspector {
 
 std::string FormatWsAddress(const std::string& host, int port,
@@ -34,143 +29,64 @@ std::string FormatWsAddress(const std::string& host, int port,
                             bool include_protocol);
 
 class InspectorIoDelegate;
-
-enum class InspectorAction {
-  kStartSession,
-  kStartSessionUnconditionally,  // First attach with --inspect-brk
-  kEndSession,
-  kSendMessage
-};
+class MainThreadHandle;
+class RequestQueue;
 
 // kKill closes connections and stops the server, kStop only stops the server
 enum class TransportAction {
   kKill,
   kSendMessage,
-  kStop,
-  kAcceptSession,
-  kDeclineSession
+  kStop
 };
 
 class InspectorIo {
  public:
-  InspectorIo(node::Environment* env, const std::string& path,
-              const DebugOptions& options, bool wait_for_connect);
-
+  // Start the inspector agent thread, waiting for it to initialize
+  // bool Start();
+  // Returns empty pointer if thread was not started
+  static std::unique_ptr<InspectorIo> Start(
+      std::shared_ptr<MainThreadHandle> main_thread, const std::string& path,
+      const DebugOptions& options);
+
+  // Will block till the transport thread shuts down
   ~InspectorIo();
-  // Start the inspector agent thread, waiting for it to initialize,
-  // and waiting as well for a connection if wait_for_connect.
-  bool Start();
-  // Stop the inspector agent thread.
-  void Stop();
-
-  bool IsStarted();
-
-  void WaitForDisconnect();
-  // Called from thread to queue an incoming message and trigger
-  // DispatchMessages() on the main thread.
-  void PostIncomingMessage(InspectorAction action, int session_id,
-                           const std::string& message);
-  void ResumeStartup() {
-    uv_sem_post(&thread_start_sem_);
-  }
-  void ServerDone() {
-    uv_close(reinterpret_cast<uv_handle_t*>(&thread_req_), nullptr);
-  }
-  bool WaitForFrontendEvent();
 
-  int port() const { return port_; }
+  void StopAcceptingNewConnections();
   std::string host() const { return options_.host_name(); }
+  int port() const { return port_; }
   std::vector<std::string> GetTargetIds() const;
 
  private:
-  template <typename Action>
-  using MessageQueue =
-      std::deque<std::tuple<Action, int,
-                  std::unique_ptr<v8_inspector::StringBuffer>>>;
-  enum class State {
-    kNew,
-    kAccepting,
-    kDone,
-    kError,
-    kShutDown
-  };
-
-  // Callback for main_thread_req_'s uv_async_t
-  static void MainThreadReqAsyncCb(uv_async_t* req);
+  InspectorIo(std::shared_ptr<MainThreadHandle> handle,
+              const std::string& path, const DebugOptions& options);
 
   // Wrapper for agent->ThreadMain()
   static void ThreadMain(void* agent);
 
   // Runs a uv_loop_t
-  template <typename Transport> void ThreadMain();
-  // Called by ThreadMain's loop when triggered by thread_req_, writes
-  // messages from outgoing_message_queue to the InspectorSockerServer
-  template <typename Transport> static void IoThreadAsyncCb(uv_async_t* async);
-
-  void DispatchMessages();
-  // Write action to outgoing_message_queue, and wake the thread
-  void Write(TransportAction action, int session_id,
-             const v8_inspector::StringView& message);
-  // Thread-safe append of message to a queue. Return true if the queue
-  // used to be empty.
-  template <typename ActionType>
-  bool AppendMessage(MessageQueue<ActionType>* vector, ActionType action,
-                     int session_id,
-                     std::unique_ptr<v8_inspector::StringBuffer> buffer);
-  // Used as equivalent of a thread-safe "pop" of an entire queue's content.
-  template <typename ActionType>
-  void SwapBehindLock(MessageQueue<ActionType>* vector1,
-                      MessageQueue<ActionType>* vector2);
-  // Attach session to an inspector. Either kAcceptSession or kDeclineSession
-  TransportAction Attach(int session_id);
-
+  void ThreadMain();
+
+  // This is a thread-safe object that will post async tasks. It lives as long
+  // as an Inspector object lives (almost as long as an Isolate).
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  // Used to post on a frontend interface thread, lives while the server is
+  // running
+  std::shared_ptr<RequestQueue> request_queue_;
   const DebugOptions options_;
 
   // The IO thread runs its own uv_loop to implement the TCP server off
   // the main thread.
   uv_thread_t thread_;
-  // Used by Start() to wait for thread to initialize, or for it to initialize
-  // and receive a connection if wait_for_connect was requested.
-  uv_sem_t thread_start_sem_;
-
-  State state_;
-  node::Environment* parent_env_;
-
-  // Attached to the uv_loop in ThreadMain()
-  uv_async_t thread_req_;
-  // Note that this will live while the async is being closed - likely, past
-  // the parent object lifespan
-  std::pair<uv_async_t, Agent*>* main_thread_req_;
-  // Will be used to post tasks from another thread
-  v8::Platform* const platform_;
-
-  // Message queues
-  ConditionVariable incoming_message_cond_;
-  Mutex state_lock_;  // Locked before mutating either queue.
-  MessageQueue<InspectorAction> incoming_message_queue_;
-  MessageQueue<TransportAction> outgoing_message_queue_;
-  // This queue is to maintain the order of the messages for the cases
-  // when we reenter the DispatchMessages function.
-  MessageQueue<InspectorAction> dispatching_message_queue_;
-
-  bool dispatching_messages_;
 
+  // For setting up interthread communications
+  Mutex thread_start_lock_;
+  ConditionVariable thread_start_condition_;
   std::string script_name_;
-  std::string script_path_;
-  const bool wait_for_connect_;
-  int port_;
-  std::unordered_map<int, std::unique_ptr<InspectorSession>> sessions_;
+  int port_ = -1;
   // May be accessed from any thread
   const std::string id_;
-
-  friend class DispatchMessagesTask;
-  friend class IoSessionDelegate;
-  friend void InterruptCallback(v8::Isolate*, void* agent);
 };
 
-std::unique_ptr<v8_inspector::StringBuffer> Utf8ToStringView(
-    const std::string& message);
-
 }  // namespace inspector
 }  // namespace node
 
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 13e91f283c912a..268c25aeb4a233 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -66,7 +66,7 @@ class JSBindingsConnection : public AsyncWrap {
                          callback_(env->isolate(), callback) {
     Agent* inspector = env->inspector_agent();
     session_ = inspector->Connect(std::unique_ptr<JSBindingsSessionDelegate>(
-        new JSBindingsSessionDelegate(env, this)));
+        new JSBindingsSessionDelegate(env, this)), false);
   }
 
   void OnMessage(Local<Value> value) {
@@ -116,7 +116,7 @@ class JSBindingsConnection : public AsyncWrap {
 
 static bool InspectorEnabled(Environment* env) {
   Agent* agent = env->inspector_agent();
-  return agent->io() != nullptr || agent->HasConnectedSessions();
+  return agent->IsActive();
 }
 
 void AddCommandLineAPI(const FunctionCallbackInfo<Value>& info) {
@@ -251,8 +251,9 @@ void Open(const FunctionCallbackInfo<Value>& args) {
   if (args.Length() > 2 && args[2]->IsBoolean()) {
     wait_for_connect = args[2]->BooleanValue(env->context()).FromJust();
   }
-
-  agent->StartIoThread(wait_for_connect);
+  agent->StartIoThread();
+  if (wait_for_connect)
+    agent->WaitForConnect();
 }
 
 void Url(const FunctionCallbackInfo<Value>& args) {
@@ -283,7 +284,7 @@ void Initialize(Local<Object> target, Local<Value> unused,
   Agent* agent = env->inspector_agent();
   env->SetMethod(target, "consoleCall", InspectorConsoleCall);
   env->SetMethod(target, "addCommandLineAPI", AddCommandLineAPI);
-  if (agent->IsWaitingForConnect())
+  if (agent->WillWaitForConnect())
     env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart);
   env->SetMethod(target, "open", Open);
   env->SetMethod(target, "url", Url);
diff --git a/src/inspector_socket_server.cc b/src/inspector_socket_server.cc
index 174dc7c726f21c..1621b408b43274 100644
--- a/src/inspector_socket_server.cc
+++ b/src/inspector_socket_server.cc
@@ -173,11 +173,8 @@ class SocketSession {
   InspectorSocket* ws_socket() {
     return ws_socket_.get();
   }
-  void set_ws_key(const std::string& ws_key) {
-    ws_key_ = ws_key;
-  }
-  void Accept() {
-    ws_socket_->AcceptUpgrade(ws_key_);
+  void Accept(const std::string& ws_key) {
+    ws_socket_->AcceptUpgrade(ws_key);
   }
   void Decline() {
     ws_socket_->CancelHandshake();
@@ -208,7 +205,6 @@ class SocketSession {
   const int id_;
   InspectorSocket::Pointer ws_socket_;
   const int server_port_;
-  std::string ws_key_;
 };
 
 class ServerSocket {
@@ -260,11 +256,11 @@ void InspectorSocketServer::SessionStarted(int session_id,
                                            const std::string& ws_key) {
   SocketSession* session = Session(session_id);
   if (!TargetExists(id)) {
-    Session(session_id)->Decline();
+    session->Decline();
     return;
   }
   connected_sessions_[session_id].first = id;
-  session->set_ws_key(ws_key);
+  session->Accept(ws_key);
   delegate_->StartSession(session_id, id);
 }
 
@@ -404,6 +400,8 @@ bool InspectorSocketServer::Start() {
 }
 
 void InspectorSocketServer::Stop() {
+  if (state_ == ServerState::kStopped)
+    return;
   CHECK_EQ(state_, ServerState::kRunning);
   state_ = ServerState::kStopped;
   server_sockets_.clear();
@@ -446,23 +444,6 @@ void InspectorSocketServer::Accept(int server_port,
   }
 }
 
-void InspectorSocketServer::AcceptSession(int session_id) {
-  SocketSession* session = Session(session_id);
-  if (session == nullptr) {
-    delegate_->EndSession(session_id);
-  } else {
-    session->Accept();
-  }
-}
-
-void InspectorSocketServer::DeclineSession(int session_id) {
-  auto it = connected_sessions_.find(session_id);
-  if (it != connected_sessions_.end()) {
-    it->second.first.clear();
-    it->second.second->Decline();
-  }
-}
-
 void InspectorSocketServer::Send(int session_id, const std::string& message) {
   SocketSession* session = Session(session_id);
   if (session != nullptr) {
diff --git a/src/inspector_socket_server.h b/src/inspector_socket_server.h
index bbc2195095772f..271be6ec555bf1 100644
--- a/src/inspector_socket_server.h
+++ b/src/inspector_socket_server.h
@@ -54,10 +54,6 @@ class InspectorSocketServer {
   void Send(int session_id, const std::string& message);
   //   kKill
   void TerminateConnections();
-  //   kAcceptSession
-  void AcceptSession(int session_id);
-  //   kDeclineSession
-  void DeclineSession(int session_id);
   int Port() const;
 
   // Session connection lifecycle
diff --git a/src/node.cc b/src/node.cc
index bbf76853ed3c8f..a9318cb82b47c5 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -323,11 +323,12 @@ static struct {
     // Inspector agent can't fail to start, but if it was configured to listen
     // right away on the websocket port and fails to bind/etc, this will return
     // false.
-    return env->inspector_agent()->Start(script_path, options);
+    return env->inspector_agent()->Start(
+        script_path == nullptr ? "" : script_path, options);
   }
 
   bool InspectorStarted(Environment* env) {
-    return env->inspector_agent()->IsStarted();
+    return env->inspector_agent()->IsListening();
   }
 #endif  // HAVE_INSPECTOR
 
@@ -1510,7 +1511,7 @@ void InitGroups(const FunctionCallbackInfo<Value>& args) {
 
 static void WaitForInspectorDisconnect(Environment* env) {
 #if HAVE_INSPECTOR
-  if (env->inspector_agent()->HasConnectedSessions()) {
+  if (env->inspector_agent()->IsActive()) {
     // Restore signal dispositions, the app is done and is no longer
     // capable of handling signals.
 #if defined(__POSIX__) && !defined(NODE_SHARED_MODE)
@@ -3517,7 +3518,7 @@ static void ParseArgs(int* argc,
 static void StartInspector(Environment* env, const char* path,
                            DebugOptions debug_options) {
 #if HAVE_INSPECTOR
-  CHECK(!env->inspector_agent()->IsStarted());
+  CHECK(!env->inspector_agent()->IsListening());
   v8_platform.StartInspector(env, path, debug_options);
 #endif  // HAVE_INSPECTOR
 }
@@ -3660,7 +3661,7 @@ static void DebugProcess(const FunctionCallbackInfo<Value>& args) {
 static void DebugEnd(const FunctionCallbackInfo<Value>& args) {
 #if HAVE_INSPECTOR
   Environment* env = Environment::GetCurrent(args);
-  if (env->inspector_agent()->IsStarted()) {
+  if (env->inspector_agent()->IsListening()) {
     env->inspector_agent()->Stop();
   }
 #endif
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index 346f442f61df0f..f44b232a1a4ad2 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -92,7 +92,7 @@ class SignalWrap : public HandleWrap {
 #if defined(__POSIX__) && HAVE_INSPECTOR
     if (signum == SIGPROF) {
       Environment* env = Environment::GetCurrent(args);
-      if (env->inspector_agent()->IsStarted()) {
+      if (env->inspector_agent()->IsListening()) {
         ProcessEmitWarning(env,
                            "process.on(SIGPROF) is reserved while debugging");
         return;
diff --git a/test/cctest/test_inspector_socket_server.cc b/test/cctest/test_inspector_socket_server.cc
index 60b7eefc5e997f..349356ef56c9fc 100644
--- a/test/cctest/test_inspector_socket_server.cc
+++ b/test/cctest/test_inspector_socket_server.cc
@@ -14,7 +14,6 @@ static const char CLIENT_CLOSE_FRAME[] = "\x88\x80\x2D\x0E\x1E\xFA";
 static const char SERVER_CLOSE_FRAME[] = "\x88\x00";
 
 static const char MAIN_TARGET_ID[] = "main-target";
-static const char UNCONNECTABLE_TARGET_ID[] = "unconnectable-target";
 
 static const char WS_HANDSHAKE_RESPONSE[] =
     "HTTP/1.1 101 Switching Protocols\r\n"
@@ -258,10 +257,6 @@ class ServerHolder {
     return server_->done();
   }
 
-  void Connected() {
-    connected++;
-  }
-
   void Disconnected() {
     disconnected++;
   }
@@ -270,9 +265,10 @@ class ServerHolder {
     delegate_done = true;
   }
 
-  void PrepareSession(int id) {
+  void Connected(int id) {
     buffer_.clear();
     session_id_ = id;
+    connected++;
   }
 
   void Received(const std::string& message) {
@@ -319,15 +315,9 @@ class TestSocketServerDelegate : public SocketServerDelegate {
 
   void StartSession(int session_id, const std::string& target_id) override {
     session_id_ = session_id;
-    harness_->PrepareSession(session_id_);
     CHECK_NE(targets_.end(),
              std::find(targets_.begin(), targets_.end(), target_id));
-    if (target_id == UNCONNECTABLE_TARGET_ID) {
-      server_->DeclineSession(session_id);
-      return;
-    }
-    harness_->Connected();
-    server_->AcceptSession(session_id);
+    harness_->Connected(session_id_);
   }
 
   void MessageReceived(int session_id, const std::string& message) override {
@@ -363,7 +353,7 @@ ServerHolder::ServerHolder(bool has_targets, uv_loop_t* loop,
                            const std::string host, int port, FILE* out) {
   std::vector<std::string> targets;
   if (has_targets)
-    targets = { MAIN_TARGET_ID, UNCONNECTABLE_TARGET_ID };
+    targets = { MAIN_TARGET_ID };
   std::unique_ptr<TestSocketServerDelegate> delegate(
       new TestSocketServerDelegate(this, targets));
   server_.reset(
@@ -414,15 +404,6 @@ TEST_F(InspectorSocketServerTest, InspectorSessions) {
 
   well_behaved_socket.Close();
 
-  // Declined connection
-  SocketWrapper declined_target_socket(&loop);
-  declined_target_socket.Connect(HOST, server.port());
-  declined_target_socket.Write(WsHandshakeRequest(UNCONNECTABLE_TARGET_ID));
-  declined_target_socket.Expect("HTTP/1.0 400 Bad Request");
-  declined_target_socket.ExpectEOF();
-  EXPECT_EQ(1, server.connected);
-  EXPECT_EQ(1, server.disconnected);
-
   // Bogus target - start session callback should not even be invoked
   SocketWrapper bogus_target_socket(&loop);
   bogus_target_socket.Connect(HOST, server.port());
@@ -491,7 +472,7 @@ TEST_F(InspectorSocketServerTest, ServerWithoutTargets) {
   // Declined connection
   SocketWrapper socket(&loop);
   socket.Connect(HOST, server.port());
-  socket.Write(WsHandshakeRequest(UNCONNECTABLE_TARGET_ID));
+  socket.Write(WsHandshakeRequest("any target id"));
   socket.Expect("HTTP/1.0 400 Bad Request");
   socket.ExpectEOF();
   server->Stop();
diff --git a/test/parallel/test-warn-sigprof.js b/test/parallel/test-warn-sigprof.js
index 71ac25443bc266..e5335215d743b6 100644
--- a/test/parallel/test-warn-sigprof.js
+++ b/test/parallel/test-warn-sigprof.js
@@ -1,3 +1,4 @@
+// Flags: --inspect=0
 'use strict';
 const common = require('../common');
 

From ae5d5658b91cdac4fe55b9e5e8c8e275449b4635 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Wed, 11 Jul 2018 20:04:28 -0700
Subject: [PATCH 067/116] test: fix flaky watchFile()

The regression that test-fs-watch-file-enoent-after-deletion was written
to test for involves whether or not the callback runs or not. Checking
what the file watcher reports unfortunately is subject to race
conditions on Windows (and possibly elsewhere) because the file watcher
returns control to the event loop before it may be receiving data from
the OS. So remove those assertions. The test still checks what it is
supposed to check, but is no longer subject to race conditions.

Fixes: https://github.com/nodejs/node/issues/21692

PR-URL: https://github.com/nodejs/node/pull/21694
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 .../test-fs-watch-file-enoent-after-deletion.js                | 3 ---
 1 file changed, 3 deletions(-)
 rename test/{sequential => parallel}/test-fs-watch-file-enoent-after-deletion.js (94%)

diff --git a/test/sequential/test-fs-watch-file-enoent-after-deletion.js b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
similarity index 94%
rename from test/sequential/test-fs-watch-file-enoent-after-deletion.js
rename to test/parallel/test-fs-watch-file-enoent-after-deletion.js
index f5b9012acabe58..83c7516c9c6ca9 100644
--- a/test/sequential/test-fs-watch-file-enoent-after-deletion.js
+++ b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
@@ -32,7 +32,6 @@ const common = require('../common');
 // stopped it from getting emitted.
 // https://github.com/nodejs/node-v0.x-archive/issues/4027
 
-const assert = require('assert');
 const path = require('path');
 const fs = require('fs');
 
@@ -43,8 +42,6 @@ const filename = path.join(tmpdir.path, 'watched');
 fs.writeFileSync(filename, 'quis custodiet ipsos custodes');
 
 fs.watchFile(filename, { interval: 50 }, common.mustCall(function(curr, prev) {
-  assert.strictEqual(prev.nlink, 1);
-  assert.strictEqual(curr.nlink, 0);
   fs.unwatchFile(filename);
 }));
 

From 15026511b857b5d9ba8050ecea022fb908eca04b Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 12 Jul 2018 19:47:52 -0700
Subject: [PATCH 068/116] test: remove timer in fs.watchFile() test

The timer was there to address a race condition that has been removed
from the test. Remove it.

PR-URL: https://github.com/nodejs/node/pull/21694
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/parallel/test-fs-watch-file-enoent-after-deletion.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-fs-watch-file-enoent-after-deletion.js b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
index 83c7516c9c6ca9..6eaa4c68c58bc8 100644
--- a/test/parallel/test-fs-watch-file-enoent-after-deletion.js
+++ b/test/parallel/test-fs-watch-file-enoent-after-deletion.js
@@ -45,4 +45,4 @@ fs.watchFile(filename, { interval: 50 }, common.mustCall(function(curr, prev) {
   fs.unwatchFile(filename);
 }));
 
-setTimeout(fs.unlinkSync, common.platformTimeout(300), filename);
+fs.unlinkSync(filename);

From 0de0f89d0c524049045ca5722ece8ecbc5f86ee7 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sat, 7 Jul 2018 15:33:06 -0700
Subject: [PATCH 069/116] doc: add "Edit on GitHub" link

Proof of concept for an "Edit on GitHub" link, inspired by the
Serverless docs.

One issue is that the link is to the version of the docs on the master
branch even if the person was reading a different version of the doc. I
don't consider that a big problem, although we can always remove the
link if it turns out to be a big problem. I don't think there is a good
solution. PRs need to be opened against the master branch generally.
Having a bunch of PRs against staging branches is probably not what we
want. If there's an update to one version of the doc, there will usually
be an update to other versions.

PR-URL: https://github.com/nodejs/node/pull/21703
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Roman Reiss <me@silverwind.io>
---
 doc/api_assets/style.css | 5 +++++
 doc/template.html        | 1 +
 tools/doc/allhtml.js     | 3 ++-
 tools/doc/html.js        | 8 ++++++++
 4 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index b4da3375d5b521..f59f3770048097 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -504,6 +504,11 @@ th > *:last-child, td > *:last-child {
   visibility: hidden;
 }
 
+.github_icon {
+  vertical-align: middle;
+  margin: -2px 3px 0 0;
+}
+
 @media only screen and (max-width: 1024px) {
   #content {
     overflow: visible;
diff --git a/doc/template.html b/doc/template.html
index bb3e2bf8b4f2f0..fdcf0d5821b56f 100644
--- a/doc/template.html
+++ b/doc/template.html
@@ -35,6 +35,7 @@ <h1>Node.js __VERSION__ Documentation</h1>
               <a href="__FILENAME__.json">View as JSON</a>
             </li>
             __ALTDOCS__
+            __EDIT_ON_GITHUB__
           </ul>
         </div>
         <hr>
diff --git a/tools/doc/allhtml.js b/tools/doc/allhtml.js
index 1c84e13d0ab79c..d185538ab683b6 100644
--- a/tools/doc/allhtml.js
+++ b/tools/doc/allhtml.js
@@ -52,7 +52,8 @@ let all = toc.replace(/index\.html/g, 'all.html')
   .replace('<a href="all.html" name="toc">', '<a href="index.html" name="toc">')
   .replace('index.json', 'all.json')
   .replace('api-section-index', 'api-section-all')
-  .replace('data-id="index"', 'data-id="all"');
+  .replace('data-id="index"', 'data-id="all"')
+  .replace(/<li class="edit_on_github">.*?<\/li>/, '');
 
 // Clean up the title.
 all = all.replace(/<title>.*?\| /, '<title>');
diff --git a/tools/doc/html.js b/tools/doc/html.js
index 0e254f1203f7a6..0f3293dadd51d1 100644
--- a/tools/doc/html.js
+++ b/tools/doc/html.js
@@ -96,6 +96,8 @@ function toHTML({ input, filename, nodeVersion, analytics }, cb) {
     HTML = HTML.replace('__ALTDOCS__', '');
   }
 
+  HTML = HTML.replace('__EDIT_ON_GITHUB__', editOnGitHub(filename));
+
   // Content insertion has to be the last thing we do with the lexed tokens,
   // because it's destructive.
   HTML = HTML.replace('__CONTENT__', marked.parser(lexed));
@@ -377,3 +379,9 @@ function altDocs(filename, docCreated) {
     </li>
   ` : '';
 }
+
+// eslint-disable-next-line max-len
+const githubLogo = '<span class="github_icon"><svg height="16" width="16" viewBox="0 0 16.1 16.1" fill="currentColor"><path d="M8 0a8 8 0 0 0-2.5 15.6c.4 0 .5-.2.5-.4v-1.5c-2 .4-2.5-.5-2.7-1 0-.1-.5-.9-.8-1-.3-.2-.7-.6 0-.6.6 0 1 .6 1.2.8.7 1.2 1.9 1 2.4.7 0-.5.2-.9.5-1-1.8-.3-3.7-1-3.7-4 0-.9.3-1.6.8-2.2 0-.2-.3-1 .1-2 0 0 .7-.3 2.2.7a7.4 7.4 0 0 1 4 0c1.5-1 2.2-.8 2.2-.8.5 1.1.2 2 .1 2.1.5.6.8 1.3.8 2.2 0 3-1.9 3.7-3.6 4 .3.2.5.7.5 1.4v2.2c0 .2.1.5.5.4A8 8 0 0 0 16 8a8 8 0 0 0-8-8z"/></svg></span>';
+function editOnGitHub(filename) {
+  return `<li class="edit_on_github"><a href="https://github.com/nodejs/node/edit/master/doc/api/${filename}.md">${githubLogo}Edit on GitHub</a></li>`;
+}

From cb698111c487f0ecba43515d1ff0ea67377ca912 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Wed, 11 Jul 2018 01:28:30 +0200
Subject: [PATCH 070/116] src: add comment on CallbackScope exception behaviour

PR-URL: https://github.com/nodejs/node/pull/21743
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Shelley Vohr <codebytere@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 src/node.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/node.h b/src/node.h
index ed2c074b922687..305d605ef4a33a 100644
--- a/src/node.h
+++ b/src/node.h
@@ -683,6 +683,10 @@ class InternalCallbackScope;
  *
  * This object should be stack-allocated to ensure that it is contained in a
  * valid HandleScope.
+ *
+ * Exceptions happening within this scope will be treated like uncaught
+ * exceptions. If this behaviour is undesirable, a new `v8::TryCatch` scope
+ * needs to be created inside of this scope.
  */
 class NODE_EXTERN CallbackScope {
  public:

From aa5994f2b94d109fc6ad200ff3b638e8a83eea5c Mon Sep 17 00:00:00 2001
From: XhmikosR <xhmikosr@gmail.com>
Date: Mon, 9 Jul 2018 18:01:13 +0300
Subject: [PATCH 071/116] src,tools: use https://nodejs.org URL when possible.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21719
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 src/node_buffer.cc         | 2 +-
 src/string_bytes.cc        | 4 ++--
 tools/msvs/msi/product.wxs | 2 +-
 tools/pkgsrc/description   | 2 +-
 tools/rpm/node.spec        | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 9465145ac37eb9..f6ebf82524d0a8 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -483,7 +483,7 @@ void StringSlice<UCS2>(const FunctionCallbackInfo<Value>& args) {
   bool release = false;
 
   // Node's "ucs2" encoding expects LE character data inside a Buffer, so we
-  // need to reorder on BE platforms.  See http://nodejs.org/api/buffer.html
+  // need to reorder on BE platforms.  See https://nodejs.org/api/buffer.html
   // regarding Node's "ucs2" encoding specification.
   const bool aligned = (reinterpret_cast<uintptr_t>(data) % sizeof(*buf) == 0);
   if (IsLittleEndian() && !aligned) {
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index 0bc2ec044ebb55..83c74d2f182021 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -343,7 +343,7 @@ size_t StringBytes::Write(Isolate* isolate,
 
       // Node's "ucs2" encoding wants LE character data stored in
       // the Buffer, so we need to reorder on BE platforms.  See
-      // http://nodejs.org/api/buffer.html regarding Node's "ucs2"
+      // https://nodejs.org/api/buffer.html regarding Node's "ucs2"
       // encoding specification
       if (IsBigEndian())
         SwapBytes16(buf, nbytes);
@@ -709,7 +709,7 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
 
   // Node's "ucs2" encoding expects LE character data inside a
   // Buffer, so we need to reorder on BE platforms.  See
-  // http://nodejs.org/api/buffer.html regarding Node's "ucs2"
+  // https://nodejs.org/api/buffer.html regarding Node's "ucs2"
   // encoding specification
   if (IsBigEndian()) {
     uint16_t* dst = node::UncheckedMalloc<uint16_t>(buflen);
diff --git a/tools/msvs/msi/product.wxs b/tools/msvs/msi/product.wxs
index c8a89d725509db..e9e4e33751d254 100755
--- a/tools/msvs/msi/product.wxs
+++ b/tools/msvs/msi/product.wxs
@@ -254,7 +254,7 @@
                        KeyPath="yes"/>
         <util:InternetShortcut Id="WebsiteShortcut"
                                Name="Node.js website"
-                               Target="http://nodejs.org"
+                               Target="https://nodejs.org/"
                                Type="url"/>
         <util:InternetShortcut Id="DocsShortcut"
                                Name="Node.js documentation"
diff --git a/tools/pkgsrc/description b/tools/pkgsrc/description
index 1cf2a08512e67f..b070f52fb6b092 100644
--- a/tools/pkgsrc/description
+++ b/tools/pkgsrc/description
@@ -4,4 +4,4 @@ intended for writing scalable network programs such as web servers.
 Packaged by nodejs.org
 
 Homepage:
-http://nodejs.org/
+https://nodejs.org/
diff --git a/tools/rpm/node.spec b/tools/rpm/node.spec
index 39b98ec5541c53..83c7b67b2a39a5 100644
--- a/tools/rpm/node.spec
+++ b/tools/rpm/node.spec
@@ -22,7 +22,7 @@ Summary: Node.js is a platform for building fast, scalable network applications.
 Group: Development/Languages
 License: MIT
 URL: https://nodejs.org/
-Source0: http://nodejs.org/dist/v%{_version}/node-v%{_version}.tar.gz
+Source0: https://nodejs.org/dist/v%{_version}/node-v%{_version}.tar.gz
 BuildRequires: gcc
 BuildRequires: gcc-c++
 BuildRequires: glibc-devel

From 961f6e8623ac297e16d40ba0ac1cc56b91754773 Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Tue, 10 Jul 2018 18:44:16 +0300
Subject: [PATCH 072/116] process: fix process.exitCode handling for
 fatalException

* set process.exitCode before calling 'exit' handlers so that there will
  not be a situation where process.exitCode !== code in 'exit' callback
  during uncaughtException handling
* don't ignore process.exitCode set in 'exit' callback when failed with
  uncaughtException and there is no uncaughtException listener

PR-URL: https://github.com/nodejs/node/pull/21739
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 doc/api/process.md                            |  8 ++-
 lib/internal/bootstrap/node.js                |  1 +
 lib/internal/worker.js                        |  3 -
 src/node.cc                                   | 11 +++-
 test/parallel/test-process-exit-code.js       | 56 ++++++++++++++++++-
 test/parallel/test-worker-exit-code.js        | 28 +++++++++-
 .../test-worker-uncaught-exception.js         | 10 ++++
 7 files changed, 109 insertions(+), 8 deletions(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index ebd84afd698872..80b70ae1151370 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -151,9 +151,13 @@ added: v0.1.18
 
 The `'uncaughtException'` event is emitted when an uncaught JavaScript
 exception bubbles all the way back to the event loop. By default, Node.js
-handles such exceptions by printing the stack trace to `stderr` and exiting.
+handles such exceptions by printing the stack trace to `stderr` and exiting
+with code 1, overriding any previously set [`process.exitCode`][].
 Adding a handler for the `'uncaughtException'` event overrides this default
-behavior.
+behavior. You may also change the [`process.exitCode`][] in
+`'uncaughtException'` handler which will result in process exiting with
+provided exit code, otherwise in the presence of such handler the process will
+exit with 0.
 
 The listener function is called with the `Error` object passed as the only
 argument.
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index df5d667aeb7b39..4256de80c2e8f5 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -449,6 +449,7 @@
         try {
           if (!process._exiting) {
             process._exiting = true;
+            process.exitCode = 1;
             process.emit('exit', 1);
           }
         } catch {
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 83389d204d285f..bcc864b5b8b330 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -454,9 +454,6 @@ function setupChild(evalScript) {
     debug(`[${threadId}] fatal exception caught = ${caught}`);
 
     if (!caught) {
-      // set correct code (uncaughtException) for [kOnExit](code) handler
-      process.exitCode = 1;
-
       let serialized;
       try {
         serialized = serializeError(error);
diff --git a/src/node.cc b/src/node.cc
index a9318cb82b47c5..e2d9b426d0cf97 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -1952,7 +1952,16 @@ void FatalException(Isolate* isolate,
       exit(7);
     } else if (caught->IsFalse()) {
       ReportException(env, error, message);
-      exit(1);
+
+      // fatal_exception_function call before may have set a new exit code ->
+      // read it again, otherwise use default for uncaughtException 1
+      Local<String> exit_code = env->exit_code_string();
+      Local<Value> code;
+      if (!process_object->Get(env->context(), exit_code).ToLocal(&code) ||
+          !code->IsInt32()) {
+        exit(1);
+      }
+      exit(code.As<v8::Int32>()->Value());
     }
   }
 }
diff --git a/test/parallel/test-process-exit-code.js b/test/parallel/test-process-exit-code.js
index f5f8099c8d2439..20004a9d7d6f58 100644
--- a/test/parallel/test-process-exit-code.js
+++ b/test/parallel/test-process-exit-code.js
@@ -34,6 +34,14 @@ switch (process.argv[2]) {
     return child4();
   case 'child5':
     return child5();
+  case 'child6':
+    return child6();
+  case 'child7':
+    return child7();
+  case 'child8':
+    return child8();
+  case 'child9':
+    return child9();
   case undefined:
     return parent();
   default:
@@ -43,6 +51,7 @@ switch (process.argv[2]) {
 function child1() {
   process.exitCode = 42;
   process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 42);
     assert.strictEqual(code, 42);
   });
 }
@@ -50,6 +59,7 @@ function child1() {
 function child2() {
   process.exitCode = 99;
   process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 42);
     assert.strictEqual(code, 42);
   });
   process.exit(42);
@@ -58,6 +68,7 @@ function child2() {
 function child3() {
   process.exitCode = 99;
   process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 0);
     assert.strictEqual(code, 0);
   });
   process.exit(0);
@@ -66,7 +77,7 @@ function child3() {
 function child4() {
   process.exitCode = 99;
   process.on('exit', function(code) {
-    if (code !== 1) {
+    if (code !== 1 || process.exitCode !== 1) {
       console.log('wrong code! expected 1 for uncaughtException');
       process.exit(99);
     }
@@ -77,11 +88,50 @@ function child4() {
 function child5() {
   process.exitCode = 95;
   process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 95);
     assert.strictEqual(code, 95);
     process.exitCode = 99;
   });
 }
 
+function child6() {
+  process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 0);
+    assert.strictEqual(code, 0);
+  });
+  process.on('uncaughtException', () => {});
+  throw new Error('ok');
+}
+
+function child7() {
+  process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 97);
+    assert.strictEqual(code, 97);
+  });
+  process.on('uncaughtException', () => {
+    process.exitCode = 97;
+  });
+  throw new Error('ok');
+}
+
+function child8() {
+  process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 98;
+  });
+  throw new Error('ok');
+}
+
+function child9() {
+  process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 0;
+  });
+  throw new Error('ok');
+}
+
 function parent() {
   const { spawn } = require('child_process');
   const node = process.execPath;
@@ -102,4 +152,8 @@ function parent() {
   test('child3', 0);
   test('child4', 1);
   test('child5', 99);
+  test('child6', 0);
+  test('child7', 97);
+  test('child8', 98);
+  test('child9', 0);
 }
diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
index b621389b49ca6b..0a1e9bb95370eb 100644
--- a/test/parallel/test-worker-exit-code.js
+++ b/test/parallel/test-worker-exit-code.js
@@ -35,6 +35,10 @@ if (!process.env.HAS_STARTED_WORKER) {
         return child6();
       case 'child7':
         return child7();
+      case 'child8':
+        return child8();
+      case 'child9':
+        return child9();
       default:
         throw new Error('invalid');
     }
@@ -105,6 +109,24 @@ function child7() {
   throw new Error('ok');
 }
 
+function child8() {
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 98;
+  });
+  throw new Error('ok');
+}
+
+function child9() {
+  process.on('exit', function(code) {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 0;
+  });
+  throw new Error('ok');
+}
+
 function parent() {
   const test = (arg, exit, error = null) => {
     const w = new Worker(__filename);
@@ -116,7 +138,9 @@ function parent() {
     }));
     if (error) {
       w.on('error', common.mustCall((err) => {
-        assert(error.test(err));
+        console.log(err);
+        assert(error.test(err),
+               `wrong error for ${arg}\nexpected:${error} but got:${err}`);
       }));
     }
     w.postMessage(arg);
@@ -129,4 +153,6 @@ function parent() {
   test('child5', 99);
   test('child6', 0);
   test('child7', 97);
+  test('child8', 98, /^Error: ok$/);
+  test('child9', 0, /^Error: ok$/);
 }
diff --git a/test/parallel/test-worker-uncaught-exception.js b/test/parallel/test-worker-uncaught-exception.js
index 67b861e22619aa..8193dccbd1ff2f 100644
--- a/test/parallel/test-worker-uncaught-exception.js
+++ b/test/parallel/test-worker-uncaught-exception.js
@@ -10,6 +10,7 @@ if (!process.env.HAS_STARTED_WORKER) {
   const w = new Worker(__filename);
   w.on('message', common.mustNotCall());
   w.on('error', common.mustCall((err) => {
+    console.log(err.message);
     assert(/^Error: foo$/.test(err));
   }));
   w.on('exit', common.mustCall((code) => {
@@ -17,5 +18,14 @@ if (!process.env.HAS_STARTED_WORKER) {
     assert.strictEqual(code, 1);
   }));
 } else {
+  // cannot use common.mustCall as it cannot catch this
+  let called = false;
+  process.on('exit', (code) => {
+    if (!called) {
+      called = true;
+    } else {
+      assert.fail('Exit callback called twice in worker');
+    }
+  });
   throw new Error('foo');
 }

From 600349aaba936c644e42ab41098a43c8c7f0fd1a Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Wed, 11 Jul 2018 00:58:01 +0300
Subject: [PATCH 073/116] test: refactor process/worker exitCode tests

PR-URL: https://github.com/nodejs/node/pull/21739
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/fixtures/process-exit-code-cases.js | 113 +++++++++++++++++++
 test/parallel/test-process-exit-code.js  | 131 +++--------------------
 test/parallel/test-worker-exit-code.js   | 123 ++-------------------
 3 files changed, 133 insertions(+), 234 deletions(-)
 create mode 100644 test/fixtures/process-exit-code-cases.js

diff --git a/test/fixtures/process-exit-code-cases.js b/test/fixtures/process-exit-code-cases.js
new file mode 100644
index 00000000000000..c8c4a2ebe6c7ff
--- /dev/null
+++ b/test/fixtures/process-exit-code-cases.js
@@ -0,0 +1,113 @@
+'use strict';
+
+const assert = require('assert');
+
+const cases = [];
+module.exports = cases;
+
+function exitsOnExitCodeSet() {
+  process.exitCode = 42;
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 42);
+    assert.strictEqual(code, 42);
+  });
+}
+cases.push({ func: exitsOnExitCodeSet, result: 42 });
+
+function changesCodeViaExit() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 42);
+    assert.strictEqual(code, 42);
+  });
+  process.exit(42);
+}
+cases.push({ func: changesCodeViaExit, result: 42 });
+
+function changesCodeZeroExit() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 0);
+    assert.strictEqual(code, 0);
+  });
+  process.exit(0);
+}
+cases.push({ func: changesCodeZeroExit, result: 0 });
+
+function exitWithOneOnUncaught() {
+  process.exitCode = 99;
+  process.on('exit', (code) => {
+    // cannot use assert because it will be uncaughtException -> 1 exit code
+    // that will render this test useless
+    if (code !== 1 || process.exitCode !== 1) {
+      console.log('wrong code! expected 1 for uncaughtException');
+      process.exit(99);
+    }
+  });
+  throw new Error('ok');
+}
+cases.push({
+  func: exitWithOneOnUncaught,
+  result: 1,
+  error: /^Error: ok$/,
+});
+
+function changeCodeInsideExit() {
+  process.exitCode = 95;
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 95);
+    assert.strictEqual(code, 95);
+    process.exitCode = 99;
+  });
+}
+cases.push({ func: changeCodeInsideExit, result: 99 });
+
+function zeroExitWithUncaughtHandler() {
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 0);
+    assert.strictEqual(code, 0);
+  });
+  process.on('uncaughtException', () => {});
+  throw new Error('ok');
+}
+cases.push({ func: zeroExitWithUncaughtHandler, result: 0 });
+
+function changeCodeInUncaughtHandler() {
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 97);
+    assert.strictEqual(code, 97);
+  });
+  process.on('uncaughtException', () => {
+    process.exitCode = 97;
+  });
+  throw new Error('ok');
+}
+cases.push({ func: changeCodeInUncaughtHandler, result: 97 });
+
+function changeCodeInExitWithUncaught() {
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 98;
+  });
+  throw new Error('ok');
+}
+cases.push({
+  func: changeCodeInExitWithUncaught,
+  result: 98,
+  error: /^Error: ok$/,
+});
+
+function exitWithZeroInExitWithUncaught() {
+  process.on('exit', (code) => {
+    assert.strictEqual(process.exitCode, 1);
+    assert.strictEqual(code, 1);
+    process.exitCode = 0;
+  });
+  throw new Error('ok');
+}
+cases.push({
+  func: exitWithZeroInExitWithUncaught,
+  result: 0,
+  error: /^Error: ok$/,
+});
diff --git a/test/parallel/test-process-exit-code.js b/test/parallel/test-process-exit-code.js
index 20004a9d7d6f58..9059b0b5c22487 100644
--- a/test/parallel/test-process-exit-code.js
+++ b/test/parallel/test-process-exit-code.js
@@ -23,113 +23,18 @@
 require('../common');
 const assert = require('assert');
 
-switch (process.argv[2]) {
-  case 'child1':
-    return child1();
-  case 'child2':
-    return child2();
-  case 'child3':
-    return child3();
-  case 'child4':
-    return child4();
-  case 'child5':
-    return child5();
-  case 'child6':
-    return child6();
-  case 'child7':
-    return child7();
-  case 'child8':
-    return child8();
-  case 'child9':
-    return child9();
-  case undefined:
-    return parent();
-  default:
-    throw new Error('invalid');
-}
-
-function child1() {
-  process.exitCode = 42;
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 42);
-    assert.strictEqual(code, 42);
-  });
-}
-
-function child2() {
-  process.exitCode = 99;
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 42);
-    assert.strictEqual(code, 42);
-  });
-  process.exit(42);
-}
-
-function child3() {
-  process.exitCode = 99;
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 0);
-    assert.strictEqual(code, 0);
-  });
-  process.exit(0);
-}
-
-function child4() {
-  process.exitCode = 99;
-  process.on('exit', function(code) {
-    if (code !== 1 || process.exitCode !== 1) {
-      console.log('wrong code! expected 1 for uncaughtException');
-      process.exit(99);
-    }
-  });
-  throw new Error('ok');
-}
-
-function child5() {
-  process.exitCode = 95;
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 95);
-    assert.strictEqual(code, 95);
-    process.exitCode = 99;
-  });
-}
-
-function child6() {
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 0);
-    assert.strictEqual(code, 0);
-  });
-  process.on('uncaughtException', () => {});
-  throw new Error('ok');
-}
-
-function child7() {
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 97);
-    assert.strictEqual(code, 97);
-  });
-  process.on('uncaughtException', () => {
-    process.exitCode = 97;
-  });
-  throw new Error('ok');
-}
-
-function child8() {
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 98;
-  });
-  throw new Error('ok');
-}
+const testCases = require('../fixtures/process-exit-code-cases');
 
-function child9() {
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 0;
-  });
-  throw new Error('ok');
+if (!process.argv[2]) {
+  parent();
+} else {
+  const i = parseInt(process.argv[2]);
+  if (Number.isNaN(i)) {
+    console.log('Invalid test case index');
+    process.exit(100);
+    return;
+  }
+  testCases[i].func();
 }
 
 function parent() {
@@ -138,22 +43,14 @@ function parent() {
   const f = __filename;
   const option = { stdio: [ 0, 1, 'ignore' ] };
 
-  const test = (arg, exit) => {
+  const test = (arg, name = 'child', exit) => {
     spawn(node, [f, arg], option).on('exit', (code) => {
       assert.strictEqual(
         code, exit,
-        `wrong exit for ${arg}\nexpected:${exit} but got:${code}`);
+        `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`);
       console.log(`ok - ${arg} exited with ${exit}`);
     });
   };
 
-  test('child1', 42);
-  test('child2', 42);
-  test('child3', 0);
-  test('child4', 1);
-  test('child5', 99);
-  test('child6', 0);
-  test('child7', 97);
-  test('child8', 98);
-  test('child9', 0);
+  testCases.forEach((tc, i) => test(i, tc.func.name, tc.result));
 }
diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js
index 0a1e9bb95370eb..f09b834f853b12 100644
--- a/test/parallel/test-worker-exit-code.js
+++ b/test/parallel/test-worker-exit-code.js
@@ -9,6 +9,8 @@ const assert = require('assert');
 const worker = require('worker_threads');
 const { Worker, parentPort } = worker;
 
+const testCases = require('../fixtures/process-exit-code-cases');
+
 // Do not use isMainThread so that this test itself can be run inside a Worker.
 if (!process.env.HAS_STARTED_WORKER) {
   process.env.HAS_STARTED_WORKER = 1;
@@ -19,121 +21,16 @@ if (!process.env.HAS_STARTED_WORKER) {
     process.exit(100);
     return;
   }
-  parentPort.once('message', (msg) => {
-    switch (msg) {
-      case 'child1':
-        return child1();
-      case 'child2':
-        return child2();
-      case 'child3':
-        return child3();
-      case 'child4':
-        return child4();
-      case 'child5':
-        return child5();
-      case 'child6':
-        return child6();
-      case 'child7':
-        return child7();
-      case 'child8':
-        return child8();
-      case 'child9':
-        return child9();
-      default:
-        throw new Error('invalid');
-    }
-  });
-}
-
-function child1() {
-  process.exitCode = 42;
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 42);
-  });
-}
-
-function child2() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 42);
-  });
-  process.exit(42);
-}
-
-function child3() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 0);
-  });
-  process.exit(0);
-}
-
-function child4() {
-  process.exitCode = 99;
-  process.on('exit', (code) => {
-    // cannot use assert because it will be uncaughtException -> 1 exit code
-    // that will render this test useless
-    if (code !== 1) {
-      console.error('wrong code! expected 1 for uncaughtException');
-      process.exit(99);
-    }
-  });
-  throw new Error('ok');
-}
-
-function child5() {
-  process.exitCode = 95;
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 95);
-    process.exitCode = 99;
-  });
-}
-
-function child6() {
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 0);
-  });
-  process.on('uncaughtException', common.mustCall(() => {
-    // handle
-  }));
-  throw new Error('ok');
-}
-
-function child7() {
-  process.on('exit', (code) => {
-    assert.strictEqual(code, 97);
-  });
-  process.on('uncaughtException', common.mustCall(() => {
-    process.exitCode = 97;
-  }));
-  throw new Error('ok');
-}
-
-function child8() {
-  process.on('exit', (code) => {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 98;
-  });
-  throw new Error('ok');
-}
-
-function child9() {
-  process.on('exit', function(code) {
-    assert.strictEqual(process.exitCode, 1);
-    assert.strictEqual(code, 1);
-    process.exitCode = 0;
-  });
-  throw new Error('ok');
+  parentPort.once('message', (msg) => testCases[msg].func());
 }
 
 function parent() {
-  const test = (arg, exit, error = null) => {
+  const test = (arg, name = 'worker', exit, error = null) => {
     const w = new Worker(__filename);
     w.on('exit', common.mustCall((code) => {
       assert.strictEqual(
         code, exit,
-        `wrong exit for ${arg}\nexpected:${exit} but got:${code}`);
+        `wrong exit for ${arg}-${name}\nexpected:${exit} but got:${code}`);
       console.log(`ok - ${arg} exited with ${exit}`);
     }));
     if (error) {
@@ -146,13 +43,5 @@ function parent() {
     w.postMessage(arg);
   };
 
-  test('child1', 42);
-  test('child2', 42);
-  test('child3', 0);
-  test('child4', 1, /^Error: ok$/);
-  test('child5', 99);
-  test('child6', 0);
-  test('child7', 97);
-  test('child8', 98, /^Error: ok$/);
-  test('child9', 0, /^Error: ok$/);
+  testCases.forEach((tc, i) => test(i, tc.func.name, tc.result, tc.error));
 }

From b0943a655efee2b1ca023cac9668a788072d07c2 Mon Sep 17 00:00:00 2001
From: Denys Otrishko <shishugi@gmail.com>
Date: Fri, 13 Jul 2018 18:45:18 +0300
Subject: [PATCH 074/116] worker: exit after uncaught exception

Previously even after uncaught exception the worker would continue to
execute until there is no more work to do.

PR-URL: https://github.com/nodejs/node/pull/21739
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 lib/internal/worker.js                             |  2 ++
 .../test-worker-uncaught-exception-async.js        | 14 ++++++++++++++
 test/parallel/test-worker-uncaught-exception.js    |  4 ++++
 3 files changed, 20 insertions(+)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index bcc864b5b8b330..26c16f86e3e8fc 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -467,6 +467,8 @@ function setupChild(evalScript) {
       else
         port.postMessage({ type: messageTypes.COULD_NOT_SERIALIZE_ERROR });
       clearAsyncIdStack();
+
+      process.exit();
     }
   }
 }
diff --git a/test/parallel/test-worker-uncaught-exception-async.js b/test/parallel/test-worker-uncaught-exception-async.js
index f820976c11ebcd..862b1a66d619c3 100644
--- a/test/parallel/test-worker-uncaught-exception-async.js
+++ b/test/parallel/test-worker-uncaught-exception-async.js
@@ -10,6 +10,7 @@ if (!process.env.HAS_STARTED_WORKER) {
   const w = new Worker(__filename);
   w.on('message', common.mustNotCall());
   w.on('error', common.mustCall((err) => {
+    console.log(err.message);
     assert(/^Error: foo$/.test(err));
   }));
   w.on('exit', common.mustCall((code) => {
@@ -17,6 +18,19 @@ if (!process.env.HAS_STARTED_WORKER) {
     assert.strictEqual(code, 1);
   }));
 } else {
+  // cannot use common.mustCall as it cannot catch this
+  let called = false;
+  process.on('exit', (code) => {
+    if (!called) {
+      called = true;
+    } else {
+      assert.fail('Exit callback called twice in worker');
+    }
+  });
+
+  setTimeout(() => assert.fail('Timeout executed after uncaughtException'),
+             2000);
+
   setImmediate(() => {
     throw new Error('foo');
   });
diff --git a/test/parallel/test-worker-uncaught-exception.js b/test/parallel/test-worker-uncaught-exception.js
index 8193dccbd1ff2f..95c142b6c70d64 100644
--- a/test/parallel/test-worker-uncaught-exception.js
+++ b/test/parallel/test-worker-uncaught-exception.js
@@ -27,5 +27,9 @@ if (!process.env.HAS_STARTED_WORKER) {
       assert.fail('Exit callback called twice in worker');
     }
   });
+
+  setTimeout(() => assert.fail('Timeout executed after uncaughtException'),
+             2000);
+
   throw new Error('foo');
 }

From a68b7dda5f3b754dced9a4e2e58762533a1efe34 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 2 Jun 2018 17:27:03 -0700
Subject: [PATCH 075/116] src: add node_process.cc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Begin moving `process` object function definitions out of
`node.cc` ... continuing the process of making `node.cc`
smaller and easier to maintain.

PR-URL: https://github.com/nodejs/node/pull/21105
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

Backport-PR-URL: https://github.com/nodejs/node/pull/21799
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 node.gyp             |   1 +
 src/node.cc          | 568 +------------------------------------------
 src/node_internals.h |  14 ++
 src/node_process.cc  | 542 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 566 insertions(+), 559 deletions(-)
 create mode 100644 src/node_process.cc

diff --git a/node.gyp b/node.gyp
index e0bd57dde51686..89ebb0fb95c945 100644
--- a/node.gyp
+++ b/node.gyp
@@ -350,6 +350,7 @@
         'src/node_platform.cc',
         'src/node_perf.cc',
         'src/node_postmortem_metadata.cc',
+        'src/node_process.cc',
         'src/node_serdes.cc',
         'src/node_trace_events.cc',
         'src/node_types.cc',
diff --git a/src/node.cc b/src/node.cc
index e2d9b426d0cf97..ec2d79f9f33280 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -138,11 +138,9 @@ using v8::Boolean;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Exception;
-using v8::Float64Array;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
-using v8::HeapStatistics;
 using v8::Integer;
 using v8::Isolate;
 using v8::Just;
@@ -164,7 +162,6 @@ using v8::ScriptOrigin;
 using v8::SealHandleScope;
 using v8::String;
 using v8::TryCatch;
-using v8::Uint32Array;
 using v8::Undefined;
 using v8::V8;
 using v8::Value;
@@ -284,7 +281,7 @@ bool v8_initialized = false;
 bool linux_at_secure = false;
 
 // process-relative uptime base, initialized at start-up
-static double prog_start_time;
+double prog_start_time;
 
 static Mutex node_isolate_mutex;
 static v8::Isolate* node_isolate;
@@ -388,7 +385,7 @@ static struct {
 static const unsigned kMaxSignal = 32;
 #endif
 
-static void PrintErrorString(const char* format, ...) {
+void PrintErrorString(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
 #ifdef _WIN32
@@ -1104,411 +1101,6 @@ NO_RETURN void Assert(const char* const (*args)[4]) {
   Abort();
 }
 
-
-static void Abort(const FunctionCallbackInfo<Value>& args) {
-  Abort();
-}
-
-
-void Chdir(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(env->is_main_thread());
-
-  if (args.Length() != 1 || !args[0]->IsString()) {
-    return env->ThrowTypeError("Bad argument.");
-  }
-
-  node::Utf8Value path(args.GetIsolate(), args[0]);
-  int err = uv_chdir(*path);
-  if (err) {
-    return env->ThrowUVException(err, "chdir", nullptr, *path, nullptr);
-  }
-}
-
-
-static void Cwd(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-#ifdef _WIN32
-  /* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */
-  char buf[MAX_PATH * 4];
-#else
-  char buf[PATH_MAX];
-#endif
-
-  size_t cwd_len = sizeof(buf);
-  int err = uv_cwd(buf, &cwd_len);
-  if (err) {
-    return env->ThrowUVException(err, "uv_cwd");
-  }
-
-  Local<String> cwd = String::NewFromUtf8(env->isolate(),
-                                          buf,
-                                          String::kNormalString,
-                                          cwd_len);
-  args.GetReturnValue().Set(cwd);
-}
-
-
-void Umask(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  uint32_t old;
-
-  if (args.Length() < 1 || args[0]->IsUndefined()) {
-    old = umask(0);
-    umask(static_cast<mode_t>(old));
-  } else if (!args[0]->IsInt32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("argument must be an integer or octal string.");
-  } else {
-    int oct;
-    if (args[0]->IsInt32()) {
-      oct = args[0]->Uint32Value();
-    } else {
-      oct = 0;
-      node::Utf8Value str(env->isolate(), args[0]);
-
-      // Parse the octal string.
-      for (size_t i = 0; i < str.length(); i++) {
-        char c = (*str)[i];
-        if (c > '7' || c < '0') {
-          return env->ThrowTypeError("invalid octal string");
-        }
-        oct *= 8;
-        oct += c - '0';
-      }
-    }
-    old = umask(static_cast<mode_t>(oct));
-  }
-
-  args.GetReturnValue().Set(old);
-}
-
-
-#if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
-
-static const uid_t uid_not_found = static_cast<uid_t>(-1);
-static const gid_t gid_not_found = static_cast<gid_t>(-1);
-
-
-static uid_t uid_by_name(const char* name) {
-  struct passwd pwd;
-  struct passwd* pp;
-  char buf[8192];
-
-  errno = 0;
-  pp = nullptr;
-
-  if (getpwnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr) {
-    return pp->pw_uid;
-  }
-
-  return uid_not_found;
-}
-
-
-static char* name_by_uid(uid_t uid) {
-  struct passwd pwd;
-  struct passwd* pp;
-  char buf[8192];
-  int rc;
-
-  errno = 0;
-  pp = nullptr;
-
-  if ((rc = getpwuid_r(uid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
-      pp != nullptr) {
-    return strdup(pp->pw_name);
-  }
-
-  if (rc == 0) {
-    errno = ENOENT;
-  }
-
-  return nullptr;
-}
-
-
-static gid_t gid_by_name(const char* name) {
-  struct group pwd;
-  struct group* pp;
-  char buf[8192];
-
-  errno = 0;
-  pp = nullptr;
-
-  if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr) {
-    return pp->gr_gid;
-  }
-
-  return gid_not_found;
-}
-
-
-#if 0  // For future use.
-static const char* name_by_gid(gid_t gid) {
-  struct group pwd;
-  struct group* pp;
-  char buf[8192];
-  int rc;
-
-  errno = 0;
-  pp = nullptr;
-
-  if ((rc = getgrgid_r(gid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
-      pp != nullptr) {
-    return strdup(pp->gr_name);
-  }
-
-  if (rc == 0) {
-    errno = ENOENT;
-  }
-
-  return nullptr;
-}
-#endif
-
-
-static uid_t uid_by_name(Isolate* isolate, Local<Value> value) {
-  if (value->IsUint32()) {
-    return static_cast<uid_t>(value->Uint32Value());
-  } else {
-    node::Utf8Value name(isolate, value);
-    return uid_by_name(*name);
-  }
-}
-
-
-static gid_t gid_by_name(Isolate* isolate, Local<Value> value) {
-  if (value->IsUint32()) {
-    return static_cast<gid_t>(value->Uint32Value());
-  } else {
-    node::Utf8Value name(isolate, value);
-    return gid_by_name(*name);
-  }
-}
-
-static void GetUid(const FunctionCallbackInfo<Value>& args) {
-  // uid_t is an uint32_t on all supported platforms.
-  args.GetReturnValue().Set(static_cast<uint32_t>(getuid()));
-}
-
-
-static void GetGid(const FunctionCallbackInfo<Value>& args) {
-  // gid_t is an uint32_t on all supported platforms.
-  args.GetReturnValue().Set(static_cast<uint32_t>(getgid()));
-}
-
-
-static void GetEUid(const FunctionCallbackInfo<Value>& args) {
-  // uid_t is an uint32_t on all supported platforms.
-  args.GetReturnValue().Set(static_cast<uint32_t>(geteuid()));
-}
-
-
-static void GetEGid(const FunctionCallbackInfo<Value>& args) {
-  // gid_t is an uint32_t on all supported platforms.
-  args.GetReturnValue().Set(static_cast<uint32_t>(getegid()));
-}
-
-
-void SetGid(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(env->is_main_thread());
-
-  if (!args[0]->IsUint32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("setgid argument must be a number or a string");
-  }
-
-  gid_t gid = gid_by_name(env->isolate(), args[0]);
-
-  if (gid == gid_not_found) {
-    return env->ThrowError("setgid group id does not exist");
-  }
-
-  if (setgid(gid)) {
-    return env->ThrowErrnoException(errno, "setgid");
-  }
-}
-
-
-void SetEGid(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(env->is_main_thread());
-
-  if (!args[0]->IsUint32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("setegid argument must be a number or string");
-  }
-
-  gid_t gid = gid_by_name(env->isolate(), args[0]);
-
-  if (gid == gid_not_found) {
-    return env->ThrowError("setegid group id does not exist");
-  }
-
-  if (setegid(gid)) {
-    return env->ThrowErrnoException(errno, "setegid");
-  }
-}
-
-
-void SetUid(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(env->is_main_thread());
-
-  if (!args[0]->IsUint32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("setuid argument must be a number or a string");
-  }
-
-  uid_t uid = uid_by_name(env->isolate(), args[0]);
-
-  if (uid == uid_not_found) {
-    return env->ThrowError("setuid user id does not exist");
-  }
-
-  if (setuid(uid)) {
-    return env->ThrowErrnoException(errno, "setuid");
-  }
-}
-
-
-void SetEUid(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(env->is_main_thread());
-
-  if (!args[0]->IsUint32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("seteuid argument must be a number or string");
-  }
-
-  uid_t uid = uid_by_name(env->isolate(), args[0]);
-
-  if (uid == uid_not_found) {
-    return env->ThrowError("seteuid user id does not exist");
-  }
-
-  if (seteuid(uid)) {
-    return env->ThrowErrnoException(errno, "seteuid");
-  }
-}
-
-
-static void GetGroups(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  int ngroups = getgroups(0, nullptr);
-
-  if (ngroups == -1) {
-    return env->ThrowErrnoException(errno, "getgroups");
-  }
-
-  gid_t* groups = new gid_t[ngroups];
-
-  ngroups = getgroups(ngroups, groups);
-
-  if (ngroups == -1) {
-    delete[] groups;
-    return env->ThrowErrnoException(errno, "getgroups");
-  }
-
-  Local<Array> groups_list = Array::New(env->isolate(), ngroups);
-  bool seen_egid = false;
-  gid_t egid = getegid();
-
-  for (int i = 0; i < ngroups; i++) {
-    groups_list->Set(i, Integer::New(env->isolate(), groups[i]));
-    if (groups[i] == egid)
-      seen_egid = true;
-  }
-
-  delete[] groups;
-
-  if (seen_egid == false) {
-    groups_list->Set(ngroups, Integer::New(env->isolate(), egid));
-  }
-
-  args.GetReturnValue().Set(groups_list);
-}
-
-
-void SetGroups(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  if (!args[0]->IsArray()) {
-    return env->ThrowTypeError("argument 1 must be an array");
-  }
-
-  Local<Array> groups_list = args[0].As<Array>();
-  size_t size = groups_list->Length();
-  gid_t* groups = new gid_t[size];
-
-  for (size_t i = 0; i < size; i++) {
-    gid_t gid = gid_by_name(env->isolate(), groups_list->Get(i));
-
-    if (gid == gid_not_found) {
-      delete[] groups;
-      return env->ThrowError("group name not found");
-    }
-
-    groups[i] = gid;
-  }
-
-  int rc = setgroups(size, groups);
-  delete[] groups;
-
-  if (rc == -1) {
-    return env->ThrowErrnoException(errno, "setgroups");
-  }
-}
-
-
-void InitGroups(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  if (!args[0]->IsUint32() && !args[0]->IsString()) {
-    return env->ThrowTypeError("argument 1 must be a number or a string");
-  }
-
-  if (!args[1]->IsUint32() && !args[1]->IsString()) {
-    return env->ThrowTypeError("argument 2 must be a number or a string");
-  }
-
-  node::Utf8Value arg0(env->isolate(), args[0]);
-  gid_t extra_group;
-  bool must_free;
-  char* user;
-
-  if (args[0]->IsUint32()) {
-    user = name_by_uid(args[0]->Uint32Value());
-    must_free = true;
-  } else {
-    user = *arg0;
-    must_free = false;
-  }
-
-  if (user == nullptr) {
-    return env->ThrowError("initgroups user not found");
-  }
-
-  extra_group = gid_by_name(env->isolate(), args[1]);
-
-  if (extra_group == gid_not_found) {
-    if (must_free)
-      free(user);
-    return env->ThrowError("initgroups extra group not found");
-  }
-
-  int rc = initgroups(user, extra_group);
-
-  if (must_free) {
-    free(user);
-  }
-
-  if (rc) {
-    return env->ThrowErrnoException(errno, "initgroups");
-  }
-}
-
-#endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
-
-
 static void WaitForInspectorDisconnect(Environment* env) {
 #if HAVE_INSPECTOR
   if (env->inspector_agent()->IsActive()) {
@@ -1537,113 +1129,6 @@ static void Exit(const FunctionCallbackInfo<Value>& args) {
   env->Exit(args[0]->Int32Value());
 }
 
-
-static void Uptime(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  double uptime;
-
-  uv_update_time(env->event_loop());
-  uptime = uv_now(env->event_loop()) - prog_start_time;
-
-  args.GetReturnValue().Set(Number::New(env->isolate(), uptime / 1000));
-}
-
-
-void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  size_t rss;
-  int err = uv_resident_set_memory(&rss);
-  if (err) {
-    return env->ThrowUVException(err, "uv_resident_set_memory");
-  }
-
-  Isolate* isolate = env->isolate();
-  // V8 memory usage
-  HeapStatistics v8_heap_stats;
-  isolate->GetHeapStatistics(&v8_heap_stats);
-
-  // Get the double array pointer from the Float64Array argument.
-  CHECK(args[0]->IsFloat64Array());
-  Local<Float64Array> array = args[0].As<Float64Array>();
-  CHECK_EQ(array->Length(), 4);
-  Local<ArrayBuffer> ab = array->Buffer();
-  double* fields = static_cast<double*>(ab->GetContents().Data());
-
-  fields[0] = rss;
-  fields[1] = v8_heap_stats.total_heap_size();
-  fields[2] = v8_heap_stats.used_heap_size();
-  fields[3] = isolate->AdjustAmountOfExternalAllocatedMemory(0);
-}
-
-
-static void Kill(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-
-  if (args.Length() != 2) {
-    return env->ThrowError("Bad argument.");
-  }
-
-  int pid = args[0]->Int32Value();
-  int sig = args[1]->Int32Value();
-  int err = uv_kill(pid, sig);
-  args.GetReturnValue().Set(err);
-}
-
-// used in Hrtime() below
-#define NANOS_PER_SEC 1000000000
-
-// Hrtime exposes libuv's uv_hrtime() high-resolution timer.
-// The value returned by uv_hrtime() is a 64-bit int representing nanoseconds,
-// so this function instead fills in an Uint32Array with 3 entries,
-// to avoid any integer overflow possibility.
-// The first two entries contain the second part of the value
-// broken into the upper/lower 32 bits to be converted back in JS,
-// because there is no Uint64Array in JS.
-// The third entry contains the remaining nanosecond part of the value.
-void Hrtime(const FunctionCallbackInfo<Value>& args) {
-  uint64_t t = uv_hrtime();
-
-  Local<ArrayBuffer> ab = args[0].As<Uint32Array>()->Buffer();
-  uint32_t* fields = static_cast<uint32_t*>(ab->GetContents().Data());
-
-  fields[0] = (t / NANOS_PER_SEC) >> 32;
-  fields[1] = (t / NANOS_PER_SEC) & 0xffffffff;
-  fields[2] = t % NANOS_PER_SEC;
-}
-
-// Microseconds in a second, as a float, used in CPUUsage() below
-#define MICROS_PER_SEC 1e6
-
-// CPUUsage use libuv's uv_getrusage() this-process resource usage accessor,
-// to access ru_utime (user CPU time used) and ru_stime (system CPU time used),
-// which are uv_timeval_t structs (long tv_sec, long tv_usec).
-// Returns those values as Float64 microseconds in the elements of the array
-// passed to the function.
-void CPUUsage(const FunctionCallbackInfo<Value>& args) {
-  uv_rusage_t rusage;
-
-  // Call libuv to get the values we'll return.
-  int err = uv_getrusage(&rusage);
-  if (err) {
-    // On error, return the strerror version of the error code.
-    Local<String> errmsg = OneByteString(args.GetIsolate(), uv_strerror(err));
-    args.GetReturnValue().Set(errmsg);
-    return;
-  }
-
-  // Get the double array pointer from the Float64Array argument.
-  CHECK(args[0]->IsFloat64Array());
-  Local<Float64Array> array = args[0].As<Float64Array>();
-  CHECK_EQ(array->Length(), 2);
-  Local<ArrayBuffer> ab = array->Buffer();
-  double* fields = static_cast<double*>(ab->GetContents().Data());
-
-  // Set the Float64Array elements to be user / system values in microseconds.
-  fields[0] = MICROS_PER_SEC * rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec;
-  fields[1] = MICROS_PER_SEC * rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec;
-}
-
 extern "C" void node_module_register(void* m) {
   struct node_module* mp = reinterpret_cast<struct node_module*>(m);
 
@@ -2449,18 +1934,6 @@ static void DebugEnd(const FunctionCallbackInfo<Value>& args);
 
 namespace {
 
-void StartProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  env->StartProfilerIdleNotifier();
-}
-
-
-void StopProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  env->StopProfilerIdleNotifier();
-}
-
-
 #define READONLY_PROPERTY(obj, str, var)                                      \
   do {                                                                        \
     obj->DefineOwnProperty(env->context(),                                    \
@@ -2790,6 +2263,8 @@ void SetupProcessObject(Environment* env,
 
   // define various internal methods
   if (env->is_main_thread()) {
+    env->SetMethod(process, "_debugProcess", DebugProcess);
+    env->SetMethod(process, "_debugEnd", DebugEnd);
     env->SetMethod(process,
                    "_startProfilerIdleNotifier",
                    StartProfilerIdleNotifier);
@@ -2800,11 +2275,14 @@ void SetupProcessObject(Environment* env,
     env->SetMethod(process, "chdir", Chdir);
     env->SetMethod(process, "umask", Umask);
   }
-
   env->SetMethod(process, "_getActiveRequests", GetActiveRequests);
   env->SetMethod(process, "_getActiveHandles", GetActiveHandles);
-  env->SetMethod(process, "reallyExit", Exit);
+  env->SetMethod(process, "_kill", Kill);
+
   env->SetMethod(process, "cwd", Cwd);
+  env->SetMethod(process, "dlopen", DLOpen);
+  env->SetMethod(process, "reallyExit", Exit);
+  env->SetMethod(process, "uptime", Uptime);
 
 #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
   env->SetMethod(process, "getuid", GetUid);
@@ -2813,21 +2291,6 @@ void SetupProcessObject(Environment* env,
   env->SetMethod(process, "getegid", GetEGid);
   env->SetMethod(process, "getgroups", GetGroups);
 #endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
-
-  env->SetMethod(process, "_kill", Kill);
-  env->SetMethod(process, "dlopen", DLOpen);
-
-  if (env->is_main_thread()) {
-    env->SetMethod(process, "_debugProcess", DebugProcess);
-    env->SetMethod(process, "_debugEnd", DebugEnd);
-  }
-
-  env->SetMethod(process, "hrtime", Hrtime);
-
-  env->SetMethod(process, "cpuUsage", CPUUsage);
-
-  env->SetMethod(process, "uptime", Uptime);
-  env->SetMethod(process, "memoryUsage", MemoryUsage);
 }
 
 
@@ -2848,19 +2311,6 @@ void SignalExit(int signo) {
 }
 
 
-// Most of the time, it's best to use `console.error` to write
-// to the process.stderr stream.  However, in some cases, such as
-// when debugging the stream.Writable class or the process.nextTick
-// function, it is useful to bypass JavaScript entirely.
-void RawDebug(const FunctionCallbackInfo<Value>& args) {
-  CHECK(args.Length() == 1 && args[0]->IsString() &&
-        "must be called with a single string");
-  node::Utf8Value message(args.GetIsolate(), args[0]);
-  PrintErrorString("%s\n", *message);
-  fflush(stderr);
-}
-
-
 static MaybeLocal<Function> GetBootstrapper(
     Environment* env,
     Local<String> source,
diff --git a/src/node_internals.h b/src/node_internals.h
index 042b685c5939ae..5371a5502174fd 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -931,12 +931,21 @@ static inline const char* errno_string(int errorno) {
 
 // Functions defined in node.cc that are exposed via the bootstrapper object
 
+extern double prog_start_time;
+void PrintErrorString(const char* format, ...);
+
+void Abort(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Chdir(const v8::FunctionCallbackInfo<v8::Value>& args);
 void CPUUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
+void Cwd(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Hrtime(const v8::FunctionCallbackInfo<v8::Value>& args);
+void Kill(const v8::FunctionCallbackInfo<v8::Value>& args);
 void MemoryUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
 void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
+void StartProfilerIdleNotifier(const v8::FunctionCallbackInfo<v8::Value>& args);
+void StopProfilerIdleNotifier(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Umask(const v8::FunctionCallbackInfo<v8::Value>& args);
+void Uptime(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
 void SetGid(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -945,6 +954,11 @@ void SetUid(const v8::FunctionCallbackInfo<v8::Value>& args);
 void SetEUid(const v8::FunctionCallbackInfo<v8::Value>& args);
 void SetGroups(const v8::FunctionCallbackInfo<v8::Value>& args);
 void InitGroups(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetUid(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetGid(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetEUid(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetEGid(const v8::FunctionCallbackInfo<v8::Value>& args);
+void GetGroups(const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
 
 }  // namespace node
diff --git a/src/node_process.cc b/src/node_process.cc
new file mode 100644
index 00000000000000..3313f85627b16f
--- /dev/null
+++ b/src/node_process.cc
@@ -0,0 +1,542 @@
+#include "node.h"
+#include "node_internals.h"
+#include "env.h"
+#include "env-inl.h"
+#include "util.h"
+#include "util-inl.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <limits.h>  // PATH_MAX
+#include <stdio.h>
+
+#if defined(_MSC_VER)
+#include <direct.h>
+#include <io.h>
+#define umask _umask
+typedef int mode_t;
+#else
+#include <pthread.h>
+#include <sys/resource.h>  // getrlimit, setrlimit
+#include <termios.h>  // tcgetattr, tcsetattr
+#include <unistd.h>  // setuid, getuid
+#endif
+
+#if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
+#include <pwd.h>  // getpwnam()
+#include <grp.h>  // getgrnam()
+#endif
+
+namespace node {
+
+using v8::Array;
+using v8::ArrayBuffer;
+using v8::Float64Array;
+using v8::FunctionCallbackInfo;
+using v8::HeapStatistics;
+using v8::Integer;
+using v8::Isolate;
+using v8::Local;
+using v8::Number;
+using v8::String;
+using v8::Uint32;
+using v8::Uint32Array;
+using v8::Value;
+
+// Microseconds in a second, as a float, used in CPUUsage() below
+#define MICROS_PER_SEC 1e6
+// used in Hrtime() below
+#define NANOS_PER_SEC 1000000000
+
+void Abort(const FunctionCallbackInfo<Value>& args) {
+  Abort();
+}
+
+void Chdir(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(env->is_main_thread());
+
+  if (args.Length() != 1 || !args[0]->IsString())
+    return env->ThrowTypeError("Bad argument.");
+
+  Utf8Value path(args.GetIsolate(), args[0]);
+  int err = uv_chdir(*path);
+  if (err)
+    return env->ThrowUVException(err, "chdir", nullptr, *path, nullptr);
+}
+
+// CPUUsage use libuv's uv_getrusage() this-process resource usage accessor,
+// to access ru_utime (user CPU time used) and ru_stime (system CPU time used),
+// which are uv_timeval_t structs (long tv_sec, long tv_usec).
+// Returns those values as Float64 microseconds in the elements of the array
+// passed to the function.
+void CPUUsage(const FunctionCallbackInfo<Value>& args) {
+  uv_rusage_t rusage;
+
+  // Call libuv to get the values we'll return.
+  int err = uv_getrusage(&rusage);
+  if (err) {
+    // On error, return the strerror version of the error code.
+    Local<String> errmsg = OneByteString(args.GetIsolate(), uv_strerror(err));
+    return args.GetReturnValue().Set(errmsg);
+  }
+
+  // Get the double array pointer from the Float64Array argument.
+  CHECK(args[0]->IsFloat64Array());
+  Local<Float64Array> array = args[0].As<Float64Array>();
+  CHECK_EQ(array->Length(), 2);
+  Local<ArrayBuffer> ab = array->Buffer();
+  double* fields = static_cast<double*>(ab->GetContents().Data());
+
+  // Set the Float64Array elements to be user / system values in microseconds.
+  fields[0] = MICROS_PER_SEC * rusage.ru_utime.tv_sec + rusage.ru_utime.tv_usec;
+  fields[1] = MICROS_PER_SEC * rusage.ru_stime.tv_sec + rusage.ru_stime.tv_usec;
+}
+
+void Cwd(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+#ifdef _WIN32
+  /* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */
+  char buf[MAX_PATH * 4];
+#else
+  char buf[PATH_MAX];
+#endif
+
+  size_t cwd_len = sizeof(buf);
+  int err = uv_cwd(buf, &cwd_len);
+  if (err)
+    return env->ThrowUVException(err, "uv_cwd");
+
+  Local<String> cwd = String::NewFromUtf8(env->isolate(),
+                                          buf,
+                                          String::kNormalString,
+                                          cwd_len);
+  args.GetReturnValue().Set(cwd);
+}
+
+// Hrtime exposes libuv's uv_hrtime() high-resolution timer.
+// The value returned by uv_hrtime() is a 64-bit int representing nanoseconds,
+// so this function instead fills in an Uint32Array with 3 entries,
+// to avoid any integer overflow possibility.
+// The first two entries contain the second part of the value
+// broken into the upper/lower 32 bits to be converted back in JS,
+// because there is no Uint64Array in JS.
+// The third entry contains the remaining nanosecond part of the value.
+void Hrtime(const FunctionCallbackInfo<Value>& args) {
+  uint64_t t = uv_hrtime();
+
+  Local<ArrayBuffer> ab = args[0].As<Uint32Array>()->Buffer();
+  uint32_t* fields = static_cast<uint32_t*>(ab->GetContents().Data());
+
+  fields[0] = (t / NANOS_PER_SEC) >> 32;
+  fields[1] = (t / NANOS_PER_SEC) & 0xffffffff;
+  fields[2] = t % NANOS_PER_SEC;
+}
+
+void Kill(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  if (args.Length() != 2)
+    return env->ThrowError("Bad argument.");
+
+  int pid = args[0]->Int32Value();
+  int sig = args[1]->Int32Value();
+  int err = uv_kill(pid, sig);
+  args.GetReturnValue().Set(err);
+}
+
+
+void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  size_t rss;
+  int err = uv_resident_set_memory(&rss);
+  if (err)
+    return env->ThrowUVException(err, "uv_resident_set_memory");
+
+  Isolate* isolate = env->isolate();
+  // V8 memory usage
+  HeapStatistics v8_heap_stats;
+  isolate->GetHeapStatistics(&v8_heap_stats);
+
+  // Get the double array pointer from the Float64Array argument.
+  CHECK(args[0]->IsFloat64Array());
+  Local<Float64Array> array = args[0].As<Float64Array>();
+  CHECK_EQ(array->Length(), 4);
+  Local<ArrayBuffer> ab = array->Buffer();
+  double* fields = static_cast<double*>(ab->GetContents().Data());
+
+  fields[0] = rss;
+  fields[1] = v8_heap_stats.total_heap_size();
+  fields[2] = v8_heap_stats.used_heap_size();
+  fields[3] = isolate->AdjustAmountOfExternalAllocatedMemory(0);
+}
+
+// Most of the time, it's best to use `console.error` to write
+// to the process.stderr stream.  However, in some cases, such as
+// when debugging the stream.Writable class or the process.nextTick
+// function, it is useful to bypass JavaScript entirely.
+void RawDebug(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args.Length() == 1 && args[0]->IsString() &&
+        "must be called with a single string");
+  Utf8Value message(args.GetIsolate(), args[0]);
+  PrintErrorString("%s\n", *message);
+  fflush(stderr);
+}
+
+void StartProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  env->StartProfilerIdleNotifier();
+}
+
+
+void StopProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  env->StopProfilerIdleNotifier();
+}
+
+void Umask(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  uint32_t old;
+
+  if (args.Length() < 1 || args[0]->IsUndefined()) {
+    old = umask(0);
+    umask(static_cast<mode_t>(old));
+  } else if (!args[0]->IsInt32() && !args[0]->IsString()) {
+    return env->ThrowTypeError("argument must be an integer or octal string.");
+  } else {
+    int oct;
+    if (args[0]->IsInt32()) {
+      oct = args[0]->Uint32Value();
+    } else {
+      oct = 0;
+      Utf8Value str(env->isolate(), args[0]);
+
+      // Parse the octal string.
+      for (size_t i = 0; i < str.length(); i++) {
+        char c = (*str)[i];
+        if (c > '7' || c < '0')
+          return env->ThrowTypeError("invalid octal string");
+        oct *= 8;
+        oct += c - '0';
+      }
+    }
+    old = umask(static_cast<mode_t>(oct));
+  }
+
+  args.GetReturnValue().Set(old);
+}
+
+void Uptime(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  double uptime;
+
+  uv_update_time(env->event_loop());
+  uptime = uv_now(env->event_loop()) - prog_start_time;
+
+  args.GetReturnValue().Set(Number::New(env->isolate(), uptime / 1000));
+}
+
+
+#if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
+
+static const uid_t uid_not_found = static_cast<uid_t>(-1);
+static const gid_t gid_not_found = static_cast<gid_t>(-1);
+
+
+static uid_t uid_by_name(const char* name) {
+  struct passwd pwd;
+  struct passwd* pp;
+  char buf[8192];
+
+  errno = 0;
+  pp = nullptr;
+
+  if (getpwnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr)
+    return pp->pw_uid;
+
+  return uid_not_found;
+}
+
+
+static char* name_by_uid(uid_t uid) {
+  struct passwd pwd;
+  struct passwd* pp;
+  char buf[8192];
+  int rc;
+
+  errno = 0;
+  pp = nullptr;
+
+  if ((rc = getpwuid_r(uid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
+      pp != nullptr) {
+    return strdup(pp->pw_name);
+  }
+
+  if (rc == 0)
+    errno = ENOENT;
+
+  return nullptr;
+}
+
+
+static gid_t gid_by_name(const char* name) {
+  struct group pwd;
+  struct group* pp;
+  char buf[8192];
+
+  errno = 0;
+  pp = nullptr;
+
+  if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr)
+    return pp->gr_gid;
+
+  return gid_not_found;
+}
+
+
+#if 0  // For future use.
+static const char* name_by_gid(gid_t gid) {
+  struct group pwd;
+  struct group* pp;
+  char buf[8192];
+  int rc;
+
+  errno = 0;
+  pp = nullptr;
+
+  if ((rc = getgrgid_r(gid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
+      pp != nullptr) {
+    return strdup(pp->gr_name);
+  }
+
+  if (rc == 0) {
+    errno = ENOENT;
+  }
+
+  return nullptr;
+}
+#endif
+
+
+static uid_t uid_by_name(Isolate* isolate, Local<Value> value) {
+  if (value->IsUint32()) {
+    return static_cast<uid_t>(value->Uint32Value());
+  } else {
+    Utf8Value name(isolate, value);
+    return uid_by_name(*name);
+  }
+}
+
+
+static gid_t gid_by_name(Isolate* isolate, Local<Value> value) {
+  if (value->IsUint32()) {
+    return static_cast<gid_t>(value->Uint32Value());
+  } else {
+    Utf8Value name(isolate, value);
+    return gid_by_name(*name);
+  }
+}
+
+void GetUid(const FunctionCallbackInfo<Value>& args) {
+  // uid_t is an uint32_t on all supported platforms.
+  args.GetReturnValue().Set(static_cast<uint32_t>(getuid()));
+}
+
+
+void GetGid(const FunctionCallbackInfo<Value>& args) {
+  // gid_t is an uint32_t on all supported platforms.
+  args.GetReturnValue().Set(static_cast<uint32_t>(getgid()));
+}
+
+
+void GetEUid(const FunctionCallbackInfo<Value>& args) {
+  // uid_t is an uint32_t on all supported platforms.
+  args.GetReturnValue().Set(static_cast<uint32_t>(geteuid()));
+}
+
+
+void GetEGid(const FunctionCallbackInfo<Value>& args) {
+  // gid_t is an uint32_t on all supported platforms.
+  args.GetReturnValue().Set(static_cast<uint32_t>(getegid()));
+}
+
+
+void SetGid(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(env->is_main_thread());
+
+  if (!args[0]->IsUint32() && !args[0]->IsString())
+    return env->ThrowTypeError("setgid argument must be a number or a string");
+
+  gid_t gid = gid_by_name(env->isolate(), args[0]);
+
+  if (gid == gid_not_found)
+    return env->ThrowError("setgid group id does not exist");
+
+  if (setgid(gid))
+    return env->ThrowErrnoException(errno, "setgid");
+}
+
+
+void SetEGid(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(env->is_main_thread());
+
+  if (!args[0]->IsUint32() && !args[0]->IsString())
+    return env->ThrowTypeError("setegid argument must be a number or string");
+
+  gid_t gid = gid_by_name(env->isolate(), args[0]);
+
+  if (gid == gid_not_found)
+    return env->ThrowError("setegid group id does not exist");
+
+  if (setegid(gid))
+    return env->ThrowErrnoException(errno, "setegid");
+}
+
+
+void SetUid(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(env->is_main_thread());
+
+  if (!args[0]->IsUint32() && !args[0]->IsString())
+    return env->ThrowTypeError("setuid argument must be a number or a string");
+
+  uid_t uid = uid_by_name(env->isolate(), args[0]);
+
+  if (uid == uid_not_found)
+    return env->ThrowError("setuid user id does not exist");
+
+  if (setuid(uid))
+    return env->ThrowErrnoException(errno, "setuid");
+}
+
+
+void SetEUid(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(env->is_main_thread());
+
+  if (!args[0]->IsUint32() && !args[0]->IsString())
+    return env->ThrowTypeError("seteuid argument must be a number or string");
+
+  uid_t uid = uid_by_name(env->isolate(), args[0]);
+
+  if (uid == uid_not_found)
+    return env->ThrowError("seteuid user id does not exist");
+
+  if (seteuid(uid))
+    return env->ThrowErrnoException(errno, "seteuid");
+}
+
+
+void GetGroups(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  int ngroups = getgroups(0, nullptr);
+
+  if (ngroups == -1)
+    return env->ThrowErrnoException(errno, "getgroups");
+
+  gid_t* groups = new gid_t[ngroups];
+
+  ngroups = getgroups(ngroups, groups);
+
+  if (ngroups == -1) {
+    delete[] groups;
+    return env->ThrowErrnoException(errno, "getgroups");
+  }
+
+  Local<Array> groups_list = Array::New(env->isolate(), ngroups);
+  bool seen_egid = false;
+  gid_t egid = getegid();
+
+  for (int i = 0; i < ngroups; i++) {
+    groups_list->Set(i, Integer::New(env->isolate(), groups[i]));
+    if (groups[i] == egid)
+      seen_egid = true;
+  }
+
+  delete[] groups;
+
+  if (seen_egid == false)
+    groups_list->Set(ngroups, Integer::New(env->isolate(), egid));
+
+  args.GetReturnValue().Set(groups_list);
+}
+
+
+void SetGroups(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  if (!args[0]->IsArray())
+    return env->ThrowTypeError("argument 1 must be an array");
+
+  Local<Array> groups_list = args[0].As<Array>();
+  size_t size = groups_list->Length();
+  gid_t* groups = new gid_t[size];
+
+  for (size_t i = 0; i < size; i++) {
+    gid_t gid = gid_by_name(env->isolate(), groups_list->Get(i));
+
+    if (gid == gid_not_found) {
+      delete[] groups;
+      return env->ThrowError("group name not found");
+    }
+
+    groups[i] = gid;
+  }
+
+  int rc = setgroups(size, groups);
+  delete[] groups;
+
+  if (rc == -1)
+    return env->ThrowErrnoException(errno, "setgroups");
+}
+
+
+void InitGroups(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  if (!args[0]->IsUint32() && !args[0]->IsString())
+    return env->ThrowTypeError("argument 1 must be a number or a string");
+
+  if (!args[1]->IsUint32() && !args[1]->IsString())
+    return env->ThrowTypeError("argument 2 must be a number or a string");
+
+  Utf8Value arg0(env->isolate(), args[0]);
+  gid_t extra_group;
+  bool must_free;
+  char* user;
+
+  if (args[0]->IsUint32()) {
+    user = name_by_uid(args[0]->Uint32Value());
+    must_free = true;
+  } else {
+    user = *arg0;
+    must_free = false;
+  }
+
+  if (user == nullptr)
+    return env->ThrowError("initgroups user not found");
+
+  extra_group = gid_by_name(env->isolate(), args[1]);
+
+  if (extra_group == gid_not_found) {
+    if (must_free)
+      free(user);
+    return env->ThrowError("initgroups extra group not found");
+  }
+
+  int rc = initgroups(user, extra_group);
+
+  if (must_free)
+    free(user);
+
+  if (rc)
+    return env->ThrowErrnoException(errno, "initgroups");
+}
+
+#endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
+
+}  // namespace node

From f1b18ba4120966f9c57faa474b523a36c961fc3b Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 11 Jun 2018 17:37:09 +0800
Subject: [PATCH 076/116] process: implement process.hrtime.bigint()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21256
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
---
 doc/api/process.md                          | 32 +++++++++++++++++++++
 lib/internal/bootstrap/node.js              |  5 ++--
 lib/internal/process.js                     | 10 ++++++-
 src/bootstrapper.cc                         |  1 +
 src/node_internals.h                        |  1 +
 src/node_process.cc                         | 11 +++++++
 test/parallel/test-process-hrtime-bigint.js | 14 +++++++++
 7 files changed, 71 insertions(+), 3 deletions(-)
 create mode 100644 test/parallel/test-process-hrtime-bigint.js

diff --git a/doc/api/process.md b/doc/api/process.md
index 80b70ae1151370..df544e7f0f17b9 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1163,6 +1163,9 @@ added: v0.7.6
 * `time` {integer[]} The result of a previous call to `process.hrtime()`
 * Returns: {integer[]}
 
+This is the legacy version of [`process.hrtime.bigint()`][]
+before `bigint` was introduced in JavaScript.
+
 The `process.hrtime()` method returns the current high-resolution real time
 in a `[seconds, nanoseconds]` tuple `Array`, where `nanoseconds` is the
 remaining part of the real time that can't be represented in second precision.
@@ -1191,6 +1194,33 @@ setTimeout(() => {
 }, 1000);
 ```
 
+## process.hrtime.bigint()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {bigint}
+
+The `bigint` version of the [`process.hrtime()`][] method returning the
+current high-resolution real time in a `bigint`.
+
+Unlike [`process.hrtime()`][], it does not support an additional `time`
+argument since the difference can just be computed directly
+by subtraction of the two `bigint`s.
+
+```js
+const start = process.hrtime.bigint();
+// 191051479007711n
+
+setTimeout(() => {
+  const end = process.hrtime.bigint();
+  // 191052633396993n
+
+  console.log(`Benchmark took ${end - start} nanoseconds`);
+  // Benchmark took 1154389282 nanoseconds
+}, 1000);
+```
+
 ## process.initgroups(user, extraGroup)
 <!-- YAML
 added: v0.9.4
@@ -2035,6 +2065,8 @@ cases:
 [`process.execPath`]: #process_process_execpath
 [`process.exit()`]: #process_process_exit_code
 [`process.exitCode`]: #process_process_exitcode
+[`process.hrtime()`]: #process_process_hrtime_time
+[`process.hrtime.bigint()`]: #process_process_hrtime_bigint
 [`process.kill()`]: #process_process_kill_pid_signal
 [`process.setUncaughtExceptionCaptureCallback()`]: process.html#process_process_setuncaughtexceptioncapturecallback_fn
 [`promise.catch()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 4256de80c2e8f5..61146a32aad010 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -18,7 +18,8 @@
                               // object.
                               { _setupProcessObject, _setupNextTick,
                                 _setupPromises, _chdir, _cpuUsage,
-                                _hrtime, _memoryUsage, _rawDebug,
+                                _hrtime, _hrtimeBigInt,
+                                _memoryUsage, _rawDebug,
                                 _umask, _initgroups, _setegid, _seteuid,
                                 _setgid, _setuid, _setgroups,
                                 _shouldAbortOnUncaughtToggle },
@@ -66,7 +67,7 @@
       NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE,
     } = perf.constants;
 
-    _process.setup_hrtime(_hrtime);
+    _process.setup_hrtime(_hrtime, _hrtimeBigInt);
     _process.setup_cpuUsage(_cpuUsage);
     _process.setupMemoryUsage(_memoryUsage);
     _process.setupKillAndExit();
diff --git a/lib/internal/process.js b/lib/internal/process.js
index 45d9c77b32007f..098edaeaaff183 100644
--- a/lib/internal/process.js
+++ b/lib/internal/process.js
@@ -90,7 +90,7 @@ function setup_cpuUsage(_cpuUsage) {
 // The 3 entries filled in by the original process.hrtime contains
 // the upper/lower 32 bits of the second part of the value,
 // and the remaining nanoseconds of the value.
-function setup_hrtime(_hrtime) {
+function setup_hrtime(_hrtime, _hrtimeBigInt) {
   const hrValues = new Uint32Array(3);
 
   process.hrtime = function hrtime(time) {
@@ -115,6 +115,14 @@ function setup_hrtime(_hrtime) {
       hrValues[2]
     ];
   };
+
+  // Use a BigUint64Array in the closure because V8 does not have an API for
+  // creating a BigInt out of a uint64_t yet.
+  const hrBigintValues = new BigUint64Array(1);
+  process.hrtime.bigint = function() {
+    _hrtimeBigInt(hrBigintValues);
+    return hrBigintValues[0];
+  };
 }
 
 function setupMemoryUsage(_memoryUsage) {
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index f9db02562d9c8a..c470b99445fbd1 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -109,6 +109,7 @@ void SetupBootstrapObject(Environment* env,
   BOOTSTRAP_METHOD(_chdir, Chdir);
   BOOTSTRAP_METHOD(_cpuUsage, CPUUsage);
   BOOTSTRAP_METHOD(_hrtime, Hrtime);
+  BOOTSTRAP_METHOD(_hrtimeBigInt, HrtimeBigInt);
   BOOTSTRAP_METHOD(_memoryUsage, MemoryUsage);
   BOOTSTRAP_METHOD(_rawDebug, RawDebug);
   BOOTSTRAP_METHOD(_umask, Umask);
diff --git a/src/node_internals.h b/src/node_internals.h
index 5371a5502174fd..cd791f8c059caf 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -939,6 +939,7 @@ void Chdir(const v8::FunctionCallbackInfo<v8::Value>& args);
 void CPUUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Cwd(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Hrtime(const v8::FunctionCallbackInfo<v8::Value>& args);
+void HrtimeBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
 void Kill(const v8::FunctionCallbackInfo<v8::Value>& args);
 void MemoryUsage(const v8::FunctionCallbackInfo<v8::Value>& args);
 void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/node_process.cc b/src/node_process.cc
index 3313f85627b16f..04cf577dba538f 100644
--- a/src/node_process.cc
+++ b/src/node_process.cc
@@ -31,6 +31,7 @@ namespace node {
 
 using v8::Array;
 using v8::ArrayBuffer;
+using v8::BigUint64Array;
 using v8::Float64Array;
 using v8::FunctionCallbackInfo;
 using v8::HeapStatistics;
@@ -114,7 +115,11 @@ void Cwd(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(cwd);
 }
 
+
 // Hrtime exposes libuv's uv_hrtime() high-resolution timer.
+
+// This is the legacy version of hrtime before BigInt was introduced in
+// JavaScript.
 // The value returned by uv_hrtime() is a 64-bit int representing nanoseconds,
 // so this function instead fills in an Uint32Array with 3 entries,
 // to avoid any integer overflow possibility.
@@ -133,6 +138,12 @@ void Hrtime(const FunctionCallbackInfo<Value>& args) {
   fields[2] = t % NANOS_PER_SEC;
 }
 
+void HrtimeBigInt(const FunctionCallbackInfo<Value>& args) {
+  Local<ArrayBuffer> ab = args[0].As<BigUint64Array>()->Buffer();
+  uint64_t* fields = static_cast<uint64_t*>(ab->GetContents().Data());
+  fields[0] = uv_hrtime();
+}
+
 void Kill(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
diff --git a/test/parallel/test-process-hrtime-bigint.js b/test/parallel/test-process-hrtime-bigint.js
new file mode 100644
index 00000000000000..e5ce40a994d815
--- /dev/null
+++ b/test/parallel/test-process-hrtime-bigint.js
@@ -0,0 +1,14 @@
+'use strict';
+
+// Tests that process.hrtime.bigint() works.
+
+require('../common');
+const assert = require('assert');
+
+const start = process.hrtime.bigint();
+assert.strictEqual(typeof start, 'bigint');
+
+const end = process.hrtime.bigint();
+assert.strictEqual(typeof end, 'bigint');
+
+assert(end - start >= 0n);

From 4433ecbf30747c71a52e117a4a086dd0d678d5db Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Fri, 25 May 2018 12:11:37 +0200
Subject: [PATCH 077/116] lib: refactor cli table
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cli table used multi line template strings which are normally
not used in our code base and it also upper cased a regular function
name. This is changed by this patch.

PR-URL: https://github.com/nodejs/node/pull/20960
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 lib/internal/cli_table.js | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/lib/internal/cli_table.js b/lib/internal/cli_table.js
index 4c07d92eebdaa7..f6c711ece8e0ad 100644
--- a/lib/internal/cli_table.js
+++ b/lib/internal/cli_table.js
@@ -51,11 +51,11 @@ const table = (head, columns) => {
   for (var i = 0; i < head.length; i++) {
     const column = columns[i];
     for (var j = 0; j < longestColumn; j++) {
-      if (!rows[j])
+      if (rows[j] === undefined)
         rows[j] = [];
-      const v = rows[j][i] = HasOwnProperty(column, j) ? column[j] : '';
+      const value = rows[j][i] = HasOwnProperty(column, j) ? column[j] : '';
       const width = columnWidths[i] || 0;
-      const counted = countSymbols(v);
+      const counted = countSymbols(value);
       columnWidths[i] = Math.max(width, counted);
     }
   }
@@ -63,19 +63,16 @@ const table = (head, columns) => {
   const divider = columnWidths.map((i) =>
     tableChars.middleMiddle.repeat(i + 2));
 
-  const tl = tableChars.topLeft;
-  const tr = tableChars.topRight;
-  const lm = tableChars.leftMiddle;
-  let result = `${tl}${divider.join(tableChars.topMiddle)}${tr}
-${renderRow(head, columnWidths)}
-${lm}${divider.join(tableChars.rowMiddle)}${tableChars.rightMiddle}
-`;
+  let result = `${tableChars.topLeft}${divider.join(tableChars.topMiddle)}` +
+               `${tableChars.topRight}\n${renderRow(head, columnWidths)}\n` +
+               `${tableChars.leftMiddle}${divider.join(tableChars.rowMiddle)}` +
+               `${tableChars.rightMiddle}\n`;
 
   for (const row of rows)
     result += `${renderRow(row, columnWidths)}\n`;
 
-  result += `${tableChars.bottomLeft}${
-    divider.join(tableChars.bottomMiddle)}${tableChars.bottomRight}`;
+  result += `${tableChars.bottomLeft}${divider.join(tableChars.bottomMiddle)}` +
+            tableChars.bottomRight;
 
   return result;
 };

From a09bdb58478db6355a5a22c1dc8fbfbd94773cd2 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Fri, 25 May 2018 12:12:40 +0200
Subject: [PATCH 078/116] test: improve console table error output
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The former error output was not readable in case of an error. This
improves it by splitting the lines and therefore creating a nice and
readable diff.

PR-URL: https://github.com/nodejs/node/pull/20960
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 test/parallel/test-console-table.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-console-table.js b/test/parallel/test-console-table.js
index 2b63556acaa478..9ff4641d65923c 100644
--- a/test/parallel/test-console-table.js
+++ b/test/parallel/test-console-table.js
@@ -17,7 +17,10 @@ function test(data, only, expected) {
     only = undefined;
   }
   console.table(data, only);
-  assert.strictEqual(queue.shift(), expected.trimLeft());
+  assert.deepStrictEqual(
+    queue.shift().split('\n'),
+    expected.trimLeft().split('\n')
+  );
 }
 
 common.expectsError(() => console.table([], false), {

From 466601f47f599e138a18e42c5a0be2dbafd1f8ef Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Mon, 18 Jun 2018 05:26:43 +0200
Subject: [PATCH 079/116] src: remove .h if -inl.h is already included

This commit removes the normal header file include if an internal one
is specified as per the CPP_STYLE_GUIDE.

PR-URL: https://github.com/nodejs/node/pull/21381
Reviewed-By: Matheus Marchini <matheus@sthima.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
---
 src/bootstrapper.cc   | 1 -
 src/callback_scope.cc | 2 --
 src/exceptions.cc     | 2 --
 src/node_encoding.cc  | 2 --
 src/node_platform.cc  | 1 -
 src/node_process.cc   | 2 --
 6 files changed, 10 deletions(-)

diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index c470b99445fbd1..8bcc0493f5be6d 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1,5 +1,4 @@
 #include "node.h"
-#include "env.h"
 #include "env-inl.h"
 #include "node_internals.h"
 #include "v8.h"
diff --git a/src/callback_scope.cc b/src/callback_scope.cc
index 23e6d5b0632f2c..feb7e23b6e5f84 100644
--- a/src/callback_scope.cc
+++ b/src/callback_scope.cc
@@ -1,7 +1,5 @@
 #include "node.h"
-#include "async_wrap.h"
 #include "async_wrap-inl.h"
-#include "env.h"
 #include "env-inl.h"
 #include "v8.h"
 
diff --git a/src/exceptions.cc b/src/exceptions.cc
index 0007854595a467..4bd5ab13134c86 100644
--- a/src/exceptions.cc
+++ b/src/exceptions.cc
@@ -1,8 +1,6 @@
 #include "node.h"
 #include "node_internals.h"
-#include "env.h"
 #include "env-inl.h"
-#include "util.h"
 #include "util-inl.h"
 #include "v8.h"
 #include "uv.h"
diff --git a/src/node_encoding.cc b/src/node_encoding.cc
index 467f04e24568cb..d5c6bcab488dd2 100644
--- a/src/node_encoding.cc
+++ b/src/node_encoding.cc
@@ -1,8 +1,6 @@
 #include "node.h"
-#include "env.h"
 #include "env-inl.h"
 #include "string_bytes.h"
-#include "util.h"
 #include "util-inl.h"
 #include "v8.h"
 
diff --git a/src/node_platform.cc b/src/node_platform.cc
index fdca115e5f8f03..947622a219cdef 100644
--- a/src/node_platform.cc
+++ b/src/node_platform.cc
@@ -1,7 +1,6 @@
 #include "node_platform.h"
 #include "node_internals.h"
 
-#include "env.h"
 #include "env-inl.h"
 #include "util.h"
 #include <algorithm>
diff --git a/src/node_process.cc b/src/node_process.cc
index 04cf577dba538f..43982e6f39f769 100644
--- a/src/node_process.cc
+++ b/src/node_process.cc
@@ -1,8 +1,6 @@
 #include "node.h"
 #include "node_internals.h"
-#include "env.h"
 #include "env-inl.h"
-#include "util.h"
 #include "util-inl.h"
 #include "uv.h"
 #include "v8.h"

From 51d613db2d3984299fa9f702c96ba2560d040bb9 Mon Sep 17 00:00:00 2001
From: Timothy Gu <timothygu99@gmail.com>
Date: Fri, 22 Jun 2018 01:25:12 -0400
Subject: [PATCH 080/116] src: start annotating native code side effect

PR-URL: https://github.com/nodejs/node/pull/21458
Refs: https://github.com/nodejs/node/issues/20977
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/cares_wrap.cc       |  6 +--
 src/env-inl.h           | 70 +++++++++++++++++++++++++++++---
 src/env.h               | 17 +++++++-
 src/inspector_js_api.cc |  4 +-
 src/module_wrap.cc      | 10 ++---
 src/node.cc             | 20 ++++++----
 src/node_buffer.cc      | 28 ++++++-------
 src/node_crypto.cc      | 88 +++++++++++++++++++++++------------------
 src/node_types.cc       |  8 ++--
 src/node_url.cc         |  8 ++--
 src/node_util.cc        | 15 +++----
 src/node_v8.cc          |  3 +-
 src/stream_base-inl.h   | 33 ++++++++--------
 src/tty_wrap.cc         |  8 ++--
 14 files changed, 206 insertions(+), 112 deletions(-)

diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index af564df8053955..69a3d46668193a 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -2148,8 +2148,8 @@ void Initialize(Local<Object> target,
 
   env->SetMethod(target, "getaddrinfo", GetAddrInfo);
   env->SetMethod(target, "getnameinfo", GetNameInfo);
-  env->SetMethod(target, "isIPv6", IsIPv6);
-  env->SetMethod(target, "canonicalizeIP", CanonicalizeIP);
+  env->SetMethodNoSideEffect(target, "isIPv6", IsIPv6);
+  env->SetMethodNoSideEffect(target, "canonicalizeIP", CanonicalizeIP);
 
   env->SetMethod(target, "strerror", StrError);
 
@@ -2206,7 +2206,7 @@ void Initialize(Local<Object> target,
   env->SetProtoMethod(channel_wrap, "querySoa", Query<QuerySoaWrap>);
   env->SetProtoMethod(channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
 
-  env->SetProtoMethod(channel_wrap, "getServers", GetServers);
+  env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);
   env->SetProtoMethod(channel_wrap, "setServers", SetServers);
   env->SetProtoMethod(channel_wrap, "cancel", Cancel);
 
diff --git a/src/env-inl.h b/src/env-inl.h
index 8b878431ac65a3..b436b23b678015 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -681,17 +681,41 @@ inline void Environment::ThrowUVException(int errorno,
 inline v8::Local<v8::FunctionTemplate>
     Environment::NewFunctionTemplate(v8::FunctionCallback callback,
                                      v8::Local<v8::Signature> signature,
-                                     v8::ConstructorBehavior behavior) {
+                                     v8::ConstructorBehavior behavior,
+                                     v8::SideEffectType side_effect_type) {
   v8::Local<v8::External> external = as_external();
   return v8::FunctionTemplate::New(isolate(), callback, external,
-                                   signature, 0, behavior);
+                                   signature, 0, behavior, side_effect_type);
 }
 
 inline void Environment::SetMethod(v8::Local<v8::Object> that,
                                    const char* name,
                                    v8::FunctionCallback callback) {
   v8::Local<v8::Function> function =
-      NewFunctionTemplate(callback)->GetFunction();
+      NewFunctionTemplate(callback,
+                          v8::Local<v8::Signature>(),
+                          // TODO(TimothyGu): Investigate if SetMethod is ever
+                          // used for constructors.
+                          v8::ConstructorBehavior::kAllow,
+                          v8::SideEffectType::kHasSideEffect)->GetFunction();
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  v8::Local<v8::String> name_string =
+      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
+  that->Set(name_string, function);
+  function->SetName(name_string);  // NODE_SET_METHOD() compatibility.
+}
+
+inline void Environment::SetMethodNoSideEffect(v8::Local<v8::Object> that,
+                                               const char* name,
+                                               v8::FunctionCallback callback) {
+  v8::Local<v8::Function> function =
+      NewFunctionTemplate(callback,
+                          v8::Local<v8::Signature>(),
+                          // TODO(TimothyGu): Investigate if SetMethod is ever
+                          // used for constructors.
+                          v8::ConstructorBehavior::kAllow,
+                          v8::SideEffectType::kHasNoSideEffect)->GetFunction();
   // kInternalized strings are created in the old space.
   const v8::NewStringType type = v8::NewStringType::kInternalized;
   v8::Local<v8::String> name_string =
@@ -705,7 +729,24 @@ inline void Environment::SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
                                         v8::FunctionCallback callback) {
   v8::Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
   v8::Local<v8::FunctionTemplate> t =
-      NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow);
+      NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow,
+                          v8::SideEffectType::kHasSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  v8::Local<v8::String> name_string =
+      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
+  that->PrototypeTemplate()->Set(name_string, t);
+  t->SetClassName(name_string);  // NODE_SET_PROTOTYPE_METHOD() compatibility.
+}
+
+inline void Environment::SetProtoMethodNoSideEffect(
+    v8::Local<v8::FunctionTemplate> that,
+    const char* name,
+    v8::FunctionCallback callback) {
+  v8::Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
+  v8::Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow,
+                          v8::SideEffectType::kHasNoSideEffect);
   // kInternalized strings are created in the old space.
   const v8::NewStringType type = v8::NewStringType::kInternalized;
   v8::Local<v8::String> name_string =
@@ -717,7 +758,26 @@ inline void Environment::SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
 inline void Environment::SetTemplateMethod(v8::Local<v8::FunctionTemplate> that,
                                            const char* name,
                                            v8::FunctionCallback callback) {
-  v8::Local<v8::FunctionTemplate> t = NewFunctionTemplate(callback);
+  v8::Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(callback, v8::Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kAllow,
+                          v8::SideEffectType::kHasSideEffect);
+  // kInternalized strings are created in the old space.
+  const v8::NewStringType type = v8::NewStringType::kInternalized;
+  v8::Local<v8::String> name_string =
+      v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
+  that->Set(name_string, t);
+  t->SetClassName(name_string);  // NODE_SET_METHOD() compatibility.
+}
+
+inline void Environment::SetTemplateMethodNoSideEffect(
+    v8::Local<v8::FunctionTemplate> that,
+    const char* name,
+    v8::FunctionCallback callback) {
+  v8::Local<v8::FunctionTemplate> t =
+      NewFunctionTemplate(callback, v8::Local<v8::Signature>(),
+                          v8::ConstructorBehavior::kAllow,
+                          v8::SideEffectType::kHasNoSideEffect);
   // kInternalized strings are created in the old space.
   const v8::NewStringType type = v8::NewStringType::kInternalized;
   v8::Local<v8::String> name_string =
diff --git a/src/env.h b/src/env.h
index 38be74542b2599..ea50d019c2327f 100644
--- a/src/env.h
+++ b/src/env.h
@@ -751,12 +751,15 @@ class Environment {
                           v8::Local<v8::Signature> signature =
                               v8::Local<v8::Signature>(),
                           v8::ConstructorBehavior behavior =
-                              v8::ConstructorBehavior::kAllow);
+                              v8::ConstructorBehavior::kAllow,
+                          v8::SideEffectType side_effect =
+                              v8::SideEffectType::kHasSideEffect);
 
   // Convenience methods for NewFunctionTemplate().
   inline void SetMethod(v8::Local<v8::Object> that,
                         const char* name,
                         v8::FunctionCallback callback);
+
   inline void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
                              const char* name,
                              v8::FunctionCallback callback);
@@ -764,6 +767,18 @@ class Environment {
                                 const char* name,
                                 v8::FunctionCallback callback);
 
+  // Safe variants denote the function has no side effects.
+  inline void SetMethodNoSideEffect(v8::Local<v8::Object> that,
+                                    const char* name,
+                                    v8::FunctionCallback callback);
+  inline void SetProtoMethodNoSideEffect(v8::Local<v8::FunctionTemplate> that,
+                                         const char* name,
+                                         v8::FunctionCallback callback);
+  inline void SetTemplateMethodNoSideEffect(
+      v8::Local<v8::FunctionTemplate> that,
+      const char* name,
+      v8::FunctionCallback callback);
+
   void BeforeExit(void (*cb)(void* arg), void* arg);
   void RunBeforeExitCallbacks();
   void AtExit(void (*cb)(void* arg), void* arg);
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
index 268c25aeb4a233..a8e2e8ecafeefe 100644
--- a/src/inspector_js_api.cc
+++ b/src/inspector_js_api.cc
@@ -287,7 +287,7 @@ void Initialize(Local<Object> target, Local<Value> unused,
   if (agent->WillWaitForConnect())
     env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart);
   env->SetMethod(target, "open", Open);
-  env->SetMethod(target, "url", Url);
+  env->SetMethodNoSideEffect(target, "url", Url);
 
   env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper);
   env->SetMethod(target, "asyncTaskCanceled",
@@ -298,7 +298,7 @@ void Initialize(Local<Object> target, Local<Value> unused,
       InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);
 
   env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper);
-  env->SetMethod(target, "isEnabled", IsEnabled);
+  env->SetMethodNoSideEffect(target, "isEnabled", IsEnabled);
 
   auto conn_str = FIXED_ONE_BYTE_STRING(env->isolate(), "Connection");
   Local<FunctionTemplate> tmpl =
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 7569ef106688e2..3aba52dcde7780 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -789,11 +789,11 @@ void ModuleWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(tpl, "link", Link);
   env->SetProtoMethod(tpl, "instantiate", Instantiate);
   env->SetProtoMethod(tpl, "evaluate", Evaluate);
-  env->SetProtoMethod(tpl, "namespace", Namespace);
-  env->SetProtoMethod(tpl, "getStatus", GetStatus);
-  env->SetProtoMethod(tpl, "getError", GetError);
-  env->SetProtoMethod(tpl, "getStaticDependencySpecifiers",
-                      GetStaticDependencySpecifiers);
+  env->SetProtoMethodNoSideEffect(tpl, "namespace", Namespace);
+  env->SetProtoMethodNoSideEffect(tpl, "getStatus", GetStatus);
+  env->SetProtoMethodNoSideEffect(tpl, "getError", GetError);
+  env->SetProtoMethodNoSideEffect(tpl, "getStaticDependencySpecifiers",
+                                  GetStaticDependencySpecifiers);
 
   target->Set(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"), tpl->GetFunction());
   env->SetMethod(target, "resolve", Resolve);
diff --git a/src/node.cc b/src/node.cc
index ec2d79f9f33280..627f4958e0278c 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -160,6 +160,7 @@ using v8::Promise;
 using v8::PropertyCallbackInfo;
 using v8::ScriptOrigin;
 using v8::SealHandleScope;
+using v8::SideEffectType;
 using v8::String;
 using v8::TryCatch;
 using v8::Undefined;
@@ -1969,7 +1970,10 @@ void SetupProcessObject(Environment* env,
       title_string,
       ProcessTitleGetter,
       env->is_main_thread() ? ProcessTitleSetter : nullptr,
-      env->as_external()).FromJust());
+      env->as_external(),
+      v8::DEFAULT,
+      v8::None,
+      SideEffectType::kHasNoSideEffect).FromJust());
 
   // process.version
   READONLY_PROPERTY(process,
@@ -2279,17 +2283,17 @@ void SetupProcessObject(Environment* env,
   env->SetMethod(process, "_getActiveHandles", GetActiveHandles);
   env->SetMethod(process, "_kill", Kill);
 
-  env->SetMethod(process, "cwd", Cwd);
+  env->SetMethodNoSideEffect(process, "cwd", Cwd);
   env->SetMethod(process, "dlopen", DLOpen);
   env->SetMethod(process, "reallyExit", Exit);
-  env->SetMethod(process, "uptime", Uptime);
+  env->SetMethodNoSideEffect(process, "uptime", Uptime);
 
 #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
-  env->SetMethod(process, "getuid", GetUid);
-  env->SetMethod(process, "geteuid", GetEUid);
-  env->SetMethod(process, "getgid", GetGid);
-  env->SetMethod(process, "getegid", GetEGid);
-  env->SetMethod(process, "getgroups", GetGroups);
+  env->SetMethodNoSideEffect(process, "getuid", GetUid);
+  env->SetMethodNoSideEffect(process, "geteuid", GetEUid);
+  env->SetMethodNoSideEffect(process, "getgid", GetGid);
+  env->SetMethodNoSideEffect(process, "getegid", GetEGid);
+  env->SetMethodNoSideEffect(process, "getgroups", GetGroups);
 #endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
 }
 
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index f6ebf82524d0a8..6e25889d6e4a25 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -1083,12 +1083,12 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
   Local<Object> proto = args[0].As<Object>();
   env->set_buffer_prototype_object(proto);
 
-  env->SetMethod(proto, "asciiSlice", StringSlice<ASCII>);
-  env->SetMethod(proto, "base64Slice", StringSlice<BASE64>);
-  env->SetMethod(proto, "latin1Slice", StringSlice<LATIN1>);
-  env->SetMethod(proto, "hexSlice", StringSlice<HEX>);
-  env->SetMethod(proto, "ucs2Slice", StringSlice<UCS2>);
-  env->SetMethod(proto, "utf8Slice", StringSlice<UTF8>);
+  env->SetMethodNoSideEffect(proto, "asciiSlice", StringSlice<ASCII>);
+  env->SetMethodNoSideEffect(proto, "base64Slice", StringSlice<BASE64>);
+  env->SetMethodNoSideEffect(proto, "latin1Slice", StringSlice<LATIN1>);
+  env->SetMethodNoSideEffect(proto, "hexSlice", StringSlice<HEX>);
+  env->SetMethodNoSideEffect(proto, "ucs2Slice", StringSlice<UCS2>);
+  env->SetMethodNoSideEffect(proto, "utf8Slice", StringSlice<UTF8>);
 
   env->SetMethod(proto, "asciiWrite", StringWrite<ASCII>);
   env->SetMethod(proto, "base64Write", StringWrite<BASE64>);
@@ -1116,22 +1116,22 @@ void Initialize(Local<Object> target,
   Environment* env = Environment::GetCurrent(context);
 
   env->SetMethod(target, "setupBufferJS", SetupBufferJS);
-  env->SetMethod(target, "createFromString", CreateFromString);
+  env->SetMethodNoSideEffect(target, "createFromString", CreateFromString);
 
-  env->SetMethod(target, "byteLengthUtf8", ByteLengthUtf8);
+  env->SetMethodNoSideEffect(target, "byteLengthUtf8", ByteLengthUtf8);
   env->SetMethod(target, "copy", Copy);
-  env->SetMethod(target, "compare", Compare);
-  env->SetMethod(target, "compareOffset", CompareOffset);
+  env->SetMethodNoSideEffect(target, "compare", Compare);
+  env->SetMethodNoSideEffect(target, "compareOffset", CompareOffset);
   env->SetMethod(target, "fill", Fill);
-  env->SetMethod(target, "indexOfBuffer", IndexOfBuffer);
-  env->SetMethod(target, "indexOfNumber", IndexOfNumber);
-  env->SetMethod(target, "indexOfString", IndexOfString);
+  env->SetMethodNoSideEffect(target, "indexOfBuffer", IndexOfBuffer);
+  env->SetMethodNoSideEffect(target, "indexOfNumber", IndexOfNumber);
+  env->SetMethodNoSideEffect(target, "indexOfString", IndexOfString);
 
   env->SetMethod(target, "swap16", Swap16);
   env->SetMethod(target, "swap32", Swap32);
   env->SetMethod(target, "swap64", Swap64);
 
-  env->SetMethod(target, "encodeUtf8String", EncodeUtf8String);
+  env->SetMethodNoSideEffect(target, "encodeUtf8String", EncodeUtf8String);
 
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 2c3f983d39e9e5..3380961c8ebdfb 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -62,6 +62,7 @@ namespace crypto {
 
 using v8::Array;
 using v8::Boolean;
+using v8::ConstructorBehavior;
 using v8::Context;
 using v8::DontDelete;
 using v8::EscapableHandleScope;
@@ -83,6 +84,7 @@ using v8::Null;
 using v8::Object;
 using v8::PropertyAttribute;
 using v8::ReadOnly;
+using v8::SideEffectType;
 using v8::Signature;
 using v8::String;
 using v8::Uint32;
@@ -345,12 +347,12 @@ void SecureContext::Initialize(Environment* env, Local<Object> target) {
 #ifndef OPENSSL_NO_ENGINE
   env->SetProtoMethod(t, "setClientCertEngine", SetClientCertEngine);
 #endif  // !OPENSSL_NO_ENGINE
-  env->SetProtoMethod(t, "getTicketKeys", GetTicketKeys);
+  env->SetProtoMethodNoSideEffect(t, "getTicketKeys", GetTicketKeys);
   env->SetProtoMethod(t, "setTicketKeys", SetTicketKeys);
   env->SetProtoMethod(t, "setFreeListLength", SetFreeListLength);
   env->SetProtoMethod(t, "enableTicketKeyCallback", EnableTicketKeyCallback);
-  env->SetProtoMethod(t, "getCertificate", GetCertificate<true>);
-  env->SetProtoMethod(t, "getIssuer", GetCertificate<false>);
+  env->SetProtoMethodNoSideEffect(t, "getCertificate", GetCertificate<true>);
+  env->SetProtoMethodNoSideEffect(t, "getIssuer", GetCertificate<false>);
 
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyReturnIndex"),
          Integer::NewFromUnsigned(env->isolate(), kTicketKeyReturnIndex));
@@ -1366,32 +1368,34 @@ template <class Base>
 void SSLWrap<Base>::AddMethods(Environment* env, Local<FunctionTemplate> t) {
   HandleScope scope(env->isolate());
 
-  env->SetProtoMethod(t, "getPeerCertificate", GetPeerCertificate);
-  env->SetProtoMethod(t, "getFinished", GetFinished);
-  env->SetProtoMethod(t, "getPeerFinished", GetPeerFinished);
-  env->SetProtoMethod(t, "getSession", GetSession);
+  env->SetProtoMethodNoSideEffect(t, "getPeerCertificate", GetPeerCertificate);
+  env->SetProtoMethodNoSideEffect(t, "getFinished", GetFinished);
+  env->SetProtoMethodNoSideEffect(t, "getPeerFinished", GetPeerFinished);
+  env->SetProtoMethodNoSideEffect(t, "getSession", GetSession);
   env->SetProtoMethod(t, "setSession", SetSession);
   env->SetProtoMethod(t, "loadSession", LoadSession);
-  env->SetProtoMethod(t, "isSessionReused", IsSessionReused);
-  env->SetProtoMethod(t, "isInitFinished", IsInitFinished);
-  env->SetProtoMethod(t, "verifyError", VerifyError);
-  env->SetProtoMethod(t, "getCurrentCipher", GetCurrentCipher);
+  env->SetProtoMethodNoSideEffect(t, "isSessionReused", IsSessionReused);
+  env->SetProtoMethodNoSideEffect(t, "isInitFinished", IsInitFinished);
+  env->SetProtoMethodNoSideEffect(t, "verifyError", VerifyError);
+  env->SetProtoMethodNoSideEffect(t, "getCurrentCipher", GetCurrentCipher);
   env->SetProtoMethod(t, "endParser", EndParser);
   env->SetProtoMethod(t, "certCbDone", CertCbDone);
   env->SetProtoMethod(t, "renegotiate", Renegotiate);
   env->SetProtoMethod(t, "shutdownSSL", Shutdown);
-  env->SetProtoMethod(t, "getTLSTicket", GetTLSTicket);
+  env->SetProtoMethodNoSideEffect(t, "getTLSTicket", GetTLSTicket);
   env->SetProtoMethod(t, "newSessionDone", NewSessionDone);
   env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse);
   env->SetProtoMethod(t, "requestOCSP", RequestOCSP);
-  env->SetProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo);
-  env->SetProtoMethod(t, "getProtocol", GetProtocol);
+  env->SetProtoMethodNoSideEffect(t, "getEphemeralKeyInfo",
+                                  GetEphemeralKeyInfo);
+  env->SetProtoMethodNoSideEffect(t, "getProtocol", GetProtocol);
 
 #ifdef SSL_set_max_send_fragment
   env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment);
 #endif  // SSL_set_max_send_fragment
 
-  env->SetProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto);
+  env->SetProtoMethodNoSideEffect(t, "getALPNNegotiatedProtocol",
+                                  GetALPNNegotiatedProto);
   env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols);
 }
 
@@ -2559,7 +2563,7 @@ void CipherBase::Initialize(Environment* env, Local<Object> target) {
   env->SetProtoMethod(t, "update", Update);
   env->SetProtoMethod(t, "final", Final);
   env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding);
-  env->SetProtoMethod(t, "getAuthTag", GetAuthTag);
+  env->SetProtoMethodNoSideEffect(t, "getAuthTag", GetAuthTag);
   env->SetProtoMethod(t, "setAuthTag", SetAuthTag);
   env->SetProtoMethod(t, "setAAD", SetAAD);
 
@@ -3916,10 +3920,10 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
 
   env->SetProtoMethod(t, "generateKeys", GenerateKeys);
   env->SetProtoMethod(t, "computeSecret", ComputeSecret);
-  env->SetProtoMethod(t, "getPrime", GetPrime);
-  env->SetProtoMethod(t, "getGenerator", GetGenerator);
-  env->SetProtoMethod(t, "getPublicKey", GetPublicKey);
-  env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey);
+  env->SetProtoMethodNoSideEffect(t, "getPrime", GetPrime);
+  env->SetProtoMethodNoSideEffect(t, "getGenerator", GetGenerator);
+  env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey);
+  env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey);
   env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
   env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
 
@@ -3927,7 +3931,11 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
       FunctionTemplate::New(env->isolate(),
                             DiffieHellman::VerifyErrorGetter,
                             env->as_external(),
-                            Signature::New(env->isolate(), t));
+                            Signature::New(env->isolate(), t),
+                            /* length */ 0,
+                            // TODO(TimothyGu): should be deny
+                            ConstructorBehavior::kAllow,
+                            SideEffectType::kHasNoSideEffect);
 
   t->InstanceTemplate()->SetAccessorProperty(
       env->verify_error_string(),
@@ -3943,16 +3951,20 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
 
   env->SetProtoMethod(t2, "generateKeys", GenerateKeys);
   env->SetProtoMethod(t2, "computeSecret", ComputeSecret);
-  env->SetProtoMethod(t2, "getPrime", GetPrime);
-  env->SetProtoMethod(t2, "getGenerator", GetGenerator);
-  env->SetProtoMethod(t2, "getPublicKey", GetPublicKey);
-  env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey);
+  env->SetProtoMethodNoSideEffect(t2, "getPrime", GetPrime);
+  env->SetProtoMethodNoSideEffect(t2, "getGenerator", GetGenerator);
+  env->SetProtoMethodNoSideEffect(t2, "getPublicKey", GetPublicKey);
+  env->SetProtoMethodNoSideEffect(t2, "getPrivateKey", GetPrivateKey);
 
   Local<FunctionTemplate> verify_error_getter_templ2 =
       FunctionTemplate::New(env->isolate(),
                             DiffieHellman::VerifyErrorGetter,
                             env->as_external(),
-                            Signature::New(env->isolate(), t2));
+                            Signature::New(env->isolate(), t2),
+                            /* length */ 0,
+                            // TODO(TimothyGu): should be deny
+                            ConstructorBehavior::kAllow,
+                            SideEffectType::kHasNoSideEffect);
 
   t2->InstanceTemplate()->SetAccessorProperty(
       env->verify_error_string(),
@@ -4304,8 +4316,8 @@ void ECDH::Initialize(Environment* env, Local<Object> target) {
 
   env->SetProtoMethod(t, "generateKeys", GenerateKeys);
   env->SetProtoMethod(t, "computeSecret", ComputeSecret);
-  env->SetProtoMethod(t, "getPublicKey", GetPublicKey);
-  env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey);
+  env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey);
+  env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey);
   env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
   env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
 
@@ -5198,27 +5210,27 @@ void Initialize(Local<Object> target,
   Sign::Initialize(env, target);
   Verify::Initialize(env, target);
 
-  env->SetMethod(target, "certVerifySpkac", VerifySpkac);
-  env->SetMethod(target, "certExportPublicKey", ExportPublicKey);
-  env->SetMethod(target, "certExportChallenge", ExportChallenge);
+  env->SetMethodNoSideEffect(target, "certVerifySpkac", VerifySpkac);
+  env->SetMethodNoSideEffect(target, "certExportPublicKey", ExportPublicKey);
+  env->SetMethodNoSideEffect(target, "certExportChallenge", ExportChallenge);
 
-  env->SetMethod(target, "ECDHConvertKey", ConvertKey);
+  env->SetMethodNoSideEffect(target, "ECDHConvertKey", ConvertKey);
 #ifndef OPENSSL_NO_ENGINE
   env->SetMethod(target, "setEngine", SetEngine);
 #endif  // !OPENSSL_NO_ENGINE
 
 #ifdef NODE_FIPS_MODE
-  env->SetMethod(target, "getFipsCrypto", GetFipsCrypto);
+  env->SetMethodNoSideEffect(target, "getFipsCrypto", GetFipsCrypto);
   env->SetMethod(target, "setFipsCrypto", SetFipsCrypto);
 #endif
 
   env->SetMethod(target, "pbkdf2", PBKDF2);
   env->SetMethod(target, "randomBytes", RandomBytes);
-  env->SetMethod(target, "timingSafeEqual", TimingSafeEqual);
-  env->SetMethod(target, "getSSLCiphers", GetSSLCiphers);
-  env->SetMethod(target, "getCiphers", GetCiphers);
-  env->SetMethod(target, "getHashes", GetHashes);
-  env->SetMethod(target, "getCurves", GetCurves);
+  env->SetMethodNoSideEffect(target, "timingSafeEqual", TimingSafeEqual);
+  env->SetMethodNoSideEffect(target, "getSSLCiphers", GetSSLCiphers);
+  env->SetMethodNoSideEffect(target, "getCiphers", GetCiphers);
+  env->SetMethodNoSideEffect(target, "getHashes", GetHashes);
+  env->SetMethodNoSideEffect(target, "getCurves", GetCurves);
   env->SetMethod(target, "publicEncrypt",
                  PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
                                          EVP_PKEY_encrypt_init,
diff --git a/src/node_types.cc b/src/node_types.cc
index 5dac1f6d275b63..4872491c924989 100644
--- a/src/node_types.cc
+++ b/src/node_types.cc
@@ -56,13 +56,13 @@ void InitializeTypes(Local<Object> target,
                      Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
 
-#define V(type) env->SetMethod(target,     \
-                               "is" #type, \
-                               Is##type);
+#define V(type) env->SetMethodNoSideEffect(target,     \
+                                           "is" #type, \
+                                           Is##type);
   VALUE_METHOD_MAP(V)
 #undef V
 
-  env->SetMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer);
+  env->SetMethodNoSideEffect(target, "isAnyArrayBuffer", IsAnyArrayBuffer);
 }
 
 }  // anonymous namespace
diff --git a/src/node_url.cc b/src/node_url.cc
index 82c093d516bc4a..1cdb179ed254f5 100644
--- a/src/node_url.cc
+++ b/src/node_url.cc
@@ -2334,10 +2334,10 @@ static void Initialize(Local<Object> target,
                        void* priv) {
   Environment* env = Environment::GetCurrent(context);
   env->SetMethod(target, "parse", Parse);
-  env->SetMethod(target, "encodeAuth", EncodeAuthSet);
-  env->SetMethod(target, "toUSVString", ToUSVString);
-  env->SetMethod(target, "domainToASCII", DomainToASCII);
-  env->SetMethod(target, "domainToUnicode", DomainToUnicode);
+  env->SetMethodNoSideEffect(target, "encodeAuth", EncodeAuthSet);
+  env->SetMethodNoSideEffect(target, "toUSVString", ToUSVString);
+  env->SetMethodNoSideEffect(target, "domainToASCII", DomainToASCII);
+  env->SetMethodNoSideEffect(target, "domainToUnicode", DomainToUnicode);
   env->SetMethod(target, "setURLConstructor", SetURLConstructor);
 
 #define XX(name, _) NODE_DEFINE_CONSTANT(target, name);
diff --git a/src/node_util.cc b/src/node_util.cc
index 2db68586459ab2..724bb3603cfddd 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -212,18 +212,19 @@ void Initialize(Local<Object> target,
   V(kRejected);
 #undef V
 
-  env->SetMethod(target, "getHiddenValue", GetHiddenValue);
+  env->SetMethodNoSideEffect(target, "getHiddenValue", GetHiddenValue);
   env->SetMethod(target, "setHiddenValue", SetHiddenValue);
-  env->SetMethod(target, "getPromiseDetails", GetPromiseDetails);
-  env->SetMethod(target, "getProxyDetails", GetProxyDetails);
-  env->SetMethod(target, "safeToString", SafeToString);
-  env->SetMethod(target, "previewEntries", PreviewEntries);
+  env->SetMethodNoSideEffect(target, "getPromiseDetails", GetPromiseDetails);
+  env->SetMethodNoSideEffect(target, "getProxyDetails", GetProxyDetails);
+  env->SetMethodNoSideEffect(target, "safeToString", SafeToString);
+  env->SetMethodNoSideEffect(target, "previewEntries", PreviewEntries);
 
   env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog);
   env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog);
-  env->SetMethod(target, "watchdogHasPendingSigint", WatchdogHasPendingSigint);
+  env->SetMethodNoSideEffect(target, "watchdogHasPendingSigint",
+                             WatchdogHasPendingSigint);
 
-  env->SetMethod(target, "createPromise", CreatePromise);
+  env->SetMethodNoSideEffect(target, "createPromise", CreatePromise);
   env->SetMethod(target, "promiseResolve", PromiseResolve);
   env->SetMethod(target, "promiseReject", PromiseReject);
 
diff --git a/src/node_v8.cc b/src/node_v8.cc
index d546eeba93f4d9..fb0a9fea1e5d27 100644
--- a/src/node_v8.cc
+++ b/src/node_v8.cc
@@ -122,7 +122,8 @@ void Initialize(Local<Object> target,
                 Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
 
-  env->SetMethod(target, "cachedDataVersionTag", CachedDataVersionTag);
+  env->SetMethodNoSideEffect(target, "cachedDataVersionTag",
+                             CachedDataVersionTag);
 
   env->SetMethod(target,
                  "updateHeapStatisticsArrayBuffer",
diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h
index b53d3e5979c2a5..027b938d30df1c 100644
--- a/src/stream_base-inl.h
+++ b/src/stream_base-inl.h
@@ -275,29 +275,30 @@ void StreamBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
 
   Local<Signature> signature = Signature::New(env->isolate(), t);
 
+  // TODO(TimothyGu): None of these should have ConstructorBehavior::kAllow.
   Local<FunctionTemplate> get_fd_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetFD<Base>,
-                            env->as_external(),
-                            signature);
+      env->NewFunctionTemplate(GetFD<Base>,
+                               signature,
+                               v8::ConstructorBehavior::kAllow,
+                               v8::SideEffectType::kHasNoSideEffect);
 
   Local<FunctionTemplate> get_external_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetExternal<Base>,
-                            env->as_external(),
-                            signature);
+      env->NewFunctionTemplate(GetExternal<Base>,
+                               signature,
+                               v8::ConstructorBehavior::kAllow,
+                               v8::SideEffectType::kHasNoSideEffect);
 
   Local<FunctionTemplate> get_bytes_read_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetBytesRead<Base>,
-                            env->as_external(),
-                            signature);
+      env->NewFunctionTemplate(GetBytesRead<Base>,
+                               signature,
+                               v8::ConstructorBehavior::kAllow,
+                               v8::SideEffectType::kHasNoSideEffect);
 
   Local<FunctionTemplate> get_bytes_written_templ =
-      FunctionTemplate::New(env->isolate(),
-                            GetBytesWritten<Base>,
-                            env->as_external(),
-                            signature);
+      env->NewFunctionTemplate(GetBytesWritten<Base>,
+                               signature,
+                               v8::ConstructorBehavior::kAllow,
+                               v8::SideEffectType::kHasNoSideEffect);
 
   t->PrototypeTemplate()->SetAccessorProperty(env->fd_string(),
                                               get_fd_templ,
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index 175b32879bbb83..83b6e34d630e73 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -58,15 +58,15 @@ void TTYWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "close", HandleWrap::Close);
   env->SetProtoMethod(t, "unref", HandleWrap::Unref);
   env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);
+  env->SetProtoMethodNoSideEffect(t, "hasRef", HandleWrap::HasRef);
 
   LibuvStreamWrap::AddMethods(env, t);
 
-  env->SetProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize);
+  env->SetProtoMethodNoSideEffect(t, "getWindowSize", TTYWrap::GetWindowSize);
   env->SetProtoMethod(t, "setRawMode", SetRawMode);
 
-  env->SetMethod(target, "isTTY", IsTTY);
-  env->SetMethod(target, "guessHandleType", GuessHandleType);
+  env->SetMethodNoSideEffect(target, "isTTY", IsTTY);
+  env->SetMethodNoSideEffect(target, "guessHandleType", GuessHandleType);
 
   target->Set(ttyString, t->GetFunction());
   env->set_tty_constructor_template(t);

From 4ed5d1a62399d64fef64adb1e64654500126fe12 Mon Sep 17 00:00:00 2001
From: Jon Moss <me@jonathanmoss.me>
Date: Wed, 11 Jul 2018 13:53:05 -0400
Subject: [PATCH 081/116] src: add HandleWrap::AddWrapMethods

Extracts common setters to a single location

PR-URL: https://github.com/nodejs/node/pull/21769
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
---
 src/handle_wrap.cc       | 10 ++++++++++
 src/handle_wrap.h        |  3 +++
 src/node_messaging.cc    |  5 +----
 src/node_stat_watcher.cc |  6 ++----
 src/pipe_wrap.cc         |  7 +------
 src/process_wrap.cc      |  7 +------
 src/signal_wrap.cc       |  6 ++----
 src/tcp_wrap.cc          |  8 +-------
 src/timer_wrap.cc        |  6 +-----
 src/tty_wrap.cc          |  7 +------
 src/udp_wrap.cc          |  6 +-----
 11 files changed, 24 insertions(+), 47 deletions(-)

diff --git a/src/handle_wrap.cc b/src/handle_wrap.cc
index 4c2a33aa84459d..9281300146c4f3 100644
--- a/src/handle_wrap.cc
+++ b/src/handle_wrap.cc
@@ -29,6 +29,7 @@ namespace node {
 
 using v8::Context;
 using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
 using v8::HandleScope;
 using v8::Local;
 using v8::Object;
@@ -130,4 +131,13 @@ void HandleWrap::OnClose(uv_handle_t* handle) {
 }
 
 
+void HandleWrap::AddWrapMethods(Environment* env,
+                                Local<FunctionTemplate> t) {
+  env->SetProtoMethod(t, "close", HandleWrap::Close);
+  env->SetProtoMethodNoSideEffect(t, "hasRef", HandleWrap::HasRef);
+  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
+  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
+}
+
+
 }  // namespace node
diff --git a/src/handle_wrap.h b/src/handle_wrap.h
index bd7ef4000bad6f..443d28bf523933 100644
--- a/src/handle_wrap.h
+++ b/src/handle_wrap.h
@@ -73,6 +73,9 @@ class HandleWrap : public AsyncWrap {
   virtual void Close(
       v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
 
+  static void AddWrapMethods(Environment* env,
+                             v8::Local<v8::FunctionTemplate> constructor);
+
  protected:
   HandleWrap(Environment* env,
              v8::Local<v8::Object> object,
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index c28d0d4ea66560..20e0c7673b8fa9 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -724,15 +724,12 @@ MaybeLocal<Function> GetMessagePortConstructor(
     m->InstanceTemplate()->SetInternalFieldCount(1);
 
     AsyncWrap::AddWrapMethods(env, m);
+    HandleWrap::AddWrapMethods(env, m);
 
     env->SetProtoMethod(m, "postMessage", MessagePort::PostMessage);
     env->SetProtoMethod(m, "start", MessagePort::Start);
     env->SetProtoMethod(m, "stop", MessagePort::Stop);
     env->SetProtoMethod(m, "drain", MessagePort::Drain);
-    env->SetProtoMethod(m, "close", HandleWrap::Close);
-    env->SetProtoMethod(m, "unref", HandleWrap::Unref);
-    env->SetProtoMethod(m, "ref", HandleWrap::Ref);
-    env->SetProtoMethod(m, "hasRef", HandleWrap::HasRef);
 
     env->set_message_port_constructor_template(m);
   }
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index 767bc024e46be1..5e47476fd97a0c 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -52,11 +52,9 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {
   t->SetClassName(statWatcherString);
 
   AsyncWrap::AddWrapMethods(env, t);
+  HandleWrap::AddWrapMethods(env, t);
+
   env->SetProtoMethod(t, "start", StatWatcher::Start);
-  env->SetProtoMethod(t, "close", HandleWrap::Close);
-  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
-  env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);
 
   target->Set(statWatcherString, t->GetFunction());
 }
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index e2cc114479d5a1..a6044b6b267e47 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -77,12 +77,7 @@ void PipeWrap::Initialize(Local<Object> target,
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   AsyncWrap::AddWrapMethods(env, t);
-
-  env->SetProtoMethod(t, "close", HandleWrap::Close);
-  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
-  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);
-
+  HandleWrap::AddWrapMethods(env, t);
   LibuvStreamWrap::AddMethods(env, t);
 
   env->SetProtoMethod(t, "bind", Bind);
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 3219b1a40b9c16..b9a20c34a770ba 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -58,16 +58,11 @@ class ProcessWrap : public HandleWrap {
     constructor->SetClassName(processString);
 
     AsyncWrap::AddWrapMethods(env, constructor);
-
-    env->SetProtoMethod(constructor, "close", HandleWrap::Close);
+    HandleWrap::AddWrapMethods(env, constructor);
 
     env->SetProtoMethod(constructor, "spawn", Spawn);
     env->SetProtoMethod(constructor, "kill", Kill);
 
-    env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
-    env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
-    env->SetProtoMethod(constructor, "hasRef", HandleWrap::HasRef);
-
     target->Set(processString, constructor->GetFunction());
   }
 
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index f44b232a1a4ad2..5568d22e4c6228 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -52,10 +52,8 @@ class SignalWrap : public HandleWrap {
     constructor->SetClassName(signalString);
 
     AsyncWrap::AddWrapMethods(env, constructor);
-    env->SetProtoMethod(constructor, "close", HandleWrap::Close);
-    env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
-    env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
-    env->SetProtoMethod(constructor, "hasRef", HandleWrap::HasRef);
+    HandleWrap::AddWrapMethods(env, constructor);
+
     env->SetProtoMethod(constructor, "start", Start);
     env->SetProtoMethod(constructor, "stop", Stop);
 
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index aa130d22e02689..805e566bfab08b 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -86,13 +86,7 @@ void TCPWrap::Initialize(Local<Object> target,
   t->InstanceTemplate()->Set(env->onconnection_string(), Null(env->isolate()));
 
   AsyncWrap::AddWrapMethods(env, t, AsyncWrap::kFlagHasReset);
-
-  env->SetProtoMethod(t, "close", HandleWrap::Close);
-
-  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
-  env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);
-
+  HandleWrap::AddWrapMethods(env, t);
   LibuvStreamWrap::AddMethods(env, t);
 
   env->SetProtoMethod(t, "open", Open);
diff --git a/src/timer_wrap.cc b/src/timer_wrap.cc
index 9bce195203d686..7af6d13c61f7d2 100644
--- a/src/timer_wrap.cc
+++ b/src/timer_wrap.cc
@@ -55,11 +55,7 @@ class TimerWrap : public HandleWrap {
     env->SetTemplateMethod(constructor, "now", Now);
 
     AsyncWrap::AddWrapMethods(env, constructor);
-
-    env->SetProtoMethod(constructor, "close", HandleWrap::Close);
-    env->SetProtoMethod(constructor, "ref", HandleWrap::Ref);
-    env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
-    env->SetProtoMethod(constructor, "hasRef", HandleWrap::HasRef);
+    HandleWrap::AddWrapMethods(env, constructor);
 
     env->SetProtoMethod(constructor, "start", Start);
     env->SetProtoMethod(constructor, "stop", Stop);
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index 83b6e34d630e73..39d7ca1474ff8a 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -54,12 +54,7 @@ void TTYWrap::Initialize(Local<Object> target,
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   AsyncWrap::AddWrapMethods(env, t);
-
-  env->SetProtoMethod(t, "close", HandleWrap::Close);
-  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
-  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethodNoSideEffect(t, "hasRef", HandleWrap::HasRef);
-
+  HandleWrap::AddWrapMethods(env, t);
   LibuvStreamWrap::AddMethods(env, t);
 
   env->SetProtoMethodNoSideEffect(t, "getWindowSize", TTYWrap::GetWindowSize);
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 49f66914e2aa81..e5243319a553e7 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -119,7 +119,6 @@ void UDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "send", Send);
   env->SetProtoMethod(t, "bind6", Bind6);
   env->SetProtoMethod(t, "send6", Send6);
-  env->SetProtoMethod(t, "close", Close);
   env->SetProtoMethod(t, "recvStart", RecvStart);
   env->SetProtoMethod(t, "recvStop", RecvStop);
   env->SetProtoMethod(t, "getsockname",
@@ -133,11 +132,8 @@ void UDPWrap::Initialize(Local<Object> target,
   env->SetProtoMethod(t, "setTTL", SetTTL);
   env->SetProtoMethod(t, "bufferSize", BufferSize);
 
-  env->SetProtoMethod(t, "ref", HandleWrap::Ref);
-  env->SetProtoMethod(t, "unref", HandleWrap::Unref);
-  env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);
-
   AsyncWrap::AddWrapMethods(env, t);
+  HandleWrap::AddWrapMethods(env, t);
 
   target->Set(udpString, t->GetFunction());
   env->set_udp_constructor_function(t->GetFunction());

From d33281b36f9e4b5c8585209e501fc6c2e1f1b0c3 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Sat, 14 Jul 2018 15:10:10 +0300
Subject: [PATCH 082/116] doc: prevent some redirections
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace some redirected URLs with the final ones.

PR-URL: https://github.com/nodejs/node/pull/21811
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/async_hooks.md  | 2 +-
 doc/api/crypto.md       | 6 +++---
 doc/api/deprecations.md | 2 +-
 doc/api/fs.md           | 8 ++++----
 doc/api/index.md        | 2 +-
 doc/api/intl.md         | 2 +-
 doc/api/path.md         | 2 +-
 doc/api/process.md      | 2 +-
 doc/api/punycode.md     | 2 +-
 doc/api/repl.md         | 4 ++--
 doc/api/timers.md       | 2 +-
 doc/api/tls.md          | 2 +-
 doc/api/util.md         | 2 +-
 doc/api/v8.md           | 2 +-
 14 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/doc/api/async_hooks.md b/doc/api/async_hooks.md
index 6e5971c51d10c9..aa9e133b43e3f7 100644
--- a/doc/api/async_hooks.md
+++ b/doc/api/async_hooks.md
@@ -726,6 +726,6 @@ never be called.
 [`destroy` callback]: #async_hooks_destroy_asyncid
 [`init` callback]: #async_hooks_init_asyncid_type_triggerasyncid_resource
 [Hook Callbacks]: #async_hooks_hook_callbacks
-[PromiseHooks]: https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk
+[PromiseHooks]: https://docs.google.com/document/d/1rda3yKGHimKIhg5YeoAmCOtyURgsbTH_qaYR79FELlk/edit
 [promise execution tracking]: #async_hooks_promise_execution_tracking
 [`Worker`]: worker_threads.html#worker_threads_class_worker
diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 8482c80ce6110d..376a8c8a223d93 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2762,9 +2762,9 @@ the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
 [Crypto Constants]: #crypto_crypto_constants_1
 [HTML 5.2]: https://www.w3.org/TR/html52/changes.html#features-removed
 [HTML5's `keygen` element]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen
-[NIST SP 800-131A]: http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
-[NIST SP 800-132]: http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf
-[NIST SP 800-38D]: http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+[NIST SP 800-131A]: https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
+[NIST SP 800-132]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf
+[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
 [Nonce-Disrespecting Adversaries]: https://github.com/nonce-disrespect/nonce-disrespect
 [OpenSSL's SPKAC implementation]: https://www.openssl.org/docs/man1.1.0/apps/openssl-spkac.html
 [RFC 2412]: https://www.rfc-editor.org/rfc/rfc2412.txt
diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index 5aee444a6d6883..d771a3e0e7a02d 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -1070,5 +1070,5 @@ The option `produceCachedData` has been deprecated. Use
 [alloc_unsafe_size]: buffer.html#buffer_class_method_buffer_allocunsafe_size
 [from_arraybuffer]: buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
 [from_string_encoding]: buffer.html#buffer_class_method_buffer_from_string_encoding
-[NIST SP 800-38D]: http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
 [`REPLServer.clearBufferedCommand()`]: repl.html#repl_replserver_clearbufferedcommand
diff --git a/doc/api/fs.md b/doc/api/fs.md
index 872820a991f170..d3f981cf79964d 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -4604,7 +4604,7 @@ the file contents.
 [`Buffer.byteLength`]: buffer.html#buffer_class_method_buffer_bytelength_string_encoding
 [`Buffer`]: buffer.html#buffer_buffer
 [`FSEvents`]: https://developer.apple.com/documentation/coreservices/file_system_events
-[`ReadDirectoryChangesW`]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465%28v=vs.85%29.aspx
+[`ReadDirectoryChangesW`]: https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-readdirectorychangesw
 [`ReadStream`]: #fs_class_fs_readstream
 [`URL`]: url.html#url_the_whatwg_url_api
 [`UV_THREADPOOL_SIZE`]: cli.html#cli_uv_threadpool_size_size
@@ -4644,13 +4644,13 @@ the file contents.
 [Caveats]: #fs_caveats
 [Common System Errors]: errors.html#errors_common_system_errors
 [FS Constants]: #fs_fs_constants_1
-[MDN-Date]: https://developer.mozilla.org/en-US/JavaScript/Reference/Global_Objects/Date
+[MDN-Date]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
 [MDN-Number]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type
 [MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
 [Readable Streams]: stream.html#stream_class_stream_readable
 [Writable Stream]: stream.html#stream_class_stream_writable
 [inode]: https://en.wikipedia.org/wiki/Inode
-[Naming Files, Paths, and Namespaces]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
-[MSDN-Using-Streams]: https://msdn.microsoft.com/en-us/library/windows/desktop/bb540537.aspx
+[Naming Files, Paths, and Namespaces]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file
+[MSDN-Using-Streams]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/using-streams
 [support of file system `flags`]: #fs_file_system_flags
 [File Access Constants]: #fs_file_access_constants
diff --git a/doc/api/index.md b/doc/api/index.md
index 0b43097bf294de..5ba0da6a7fb5aa 100644
--- a/doc/api/index.md
+++ b/doc/api/index.md
@@ -61,4 +61,4 @@
 <div class="line"></div>
 
 * [GitHub Repo & Issue Tracker](https://github.com/nodejs/node)
-* [Mailing List](https://groups.google.com/group/nodejs)
+* [Mailing List](https://groups.google.com/forum/#!forum/nodejs)
diff --git a/doc/api/intl.md b/doc/api/intl.md
index fc10bf9dda2e82..cce6661521c832 100644
--- a/doc/api/intl.md
+++ b/doc/api/intl.md
@@ -209,7 +209,7 @@ to be helpful:
 [BUILDING.md#full-icu]: https://github.com/nodejs/node/blob/master/BUILDING.md#build-with-full-icu-support-all-locales-supported-by-icu
 [ECMA-262]: https://tc39.github.io/ecma262/
 [ECMA-402]: https://tc39.github.io/ecma402/
-[ICU]: http://icu-project.org/
+[ICU]: http://site.icu-project.org/
 [REPL]: repl.html#repl_repl
 [Test262]: https://github.com/tc39/test262/tree/master/test/intl402
 [WHATWG URL parser]: url.html#url_the_whatwg_url_api
diff --git a/doc/api/path.md b/doc/api/path.md
index c6960c7ee47109..887928dd1a46cb 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -564,4 +564,4 @@ of the `path` methods.
 [`path.sep`]: #path_path_sep
 [`path.win32`]: #path_path_win32
 [MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
-[namespace-prefixed path]: https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+[namespace-prefixed path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#namespaces
diff --git a/doc/api/process.md b/doc/api/process.md
index df544e7f0f17b9..2c27409d809080 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -2080,7 +2080,7 @@ cases:
 [Cluster]: cluster.html
 [debugger]: debugger.html
 [Duplex]: stream.html#stream_duplex_and_transform_streams
-[LTS]: https://github.com/nodejs/LTS/
+[LTS]: https://github.com/nodejs/Release
 [note on process I/O]: process.html#process_a_note_on_process_i_o
 [process_emit_warning]: #process_process_emitwarning_warning_type_code_ctor
 [process_warning]: #process_event_warning
diff --git a/doc/api/punycode.md b/doc/api/punycode.md
index fc67d55f85cd94..b8a3b7d629f9e5 100644
--- a/doc/api/punycode.md
+++ b/doc/api/punycode.md
@@ -149,5 +149,5 @@ added: v0.6.1
 
 Returns a string identifying the current [Punycode.js][] version number.
 
-[Punycode.js]: https://mths.be/punycode
+[Punycode.js]: https://github.com/bestiejs/punycode.js
 [Punycode]: https://tools.ietf.org/html/rfc3492
diff --git a/doc/api/repl.md b/doc/api/repl.md
index 356d5ef47e206f..cb2765eab44f8b 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -619,10 +619,10 @@ possible to connect to a long-running Node.js process without restarting it.
 
 For an example of running a "full-featured" (`terminal`) REPL over
 a `net.Server` and `net.Socket` instance, see:
-[https://gist.github.com/2209310](https://gist.github.com/2209310).
+[https://gist.github.com/TooTallNate/2209310](https://gist.github.com/TooTallNate/2209310).
 
 For an example of running a REPL instance over [curl(1)][], see:
-[https://gist.github.com/2053342](https://gist.github.com/2053342).
+[https://gist.github.com/TooTallNate/2053342](https://gist.github.com/TooTallNate/2053342).
 
 [`'uncaughtException'`]: process.html#process_event_uncaughtexception
 [`--experimental-repl-await`]: cli.html#cli_experimental_repl_await
diff --git a/doc/api/timers.md b/doc/api/timers.md
index 1eb511c3b92b48..d2029458e3d501 100644
--- a/doc/api/timers.md
+++ b/doc/api/timers.md
@@ -253,4 +253,4 @@ Cancels a `Timeout` object created by [`setTimeout()`][].
 [`setInterval()`]: timers.html#timers_setinterval_callback_delay_args
 [`setTimeout()`]: timers.html#timers_settimeout_callback_delay_args
 [`util.promisify()`]: util.html#util_util_promisify_original
-[the Node.js Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick
+[the Node.js Event Loop]: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/
diff --git a/doc/api/tls.md b/doc/api/tls.md
index 9d713088879927..5a9ee69ada4e59 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -1399,6 +1399,6 @@ where `secureSocket` has the same API as `pair.cleartext`.
 [Stream]: stream.html#stream_stream
 [TLS Session Tickets]: https://www.ietf.org/rfc/rfc5077.txt
 [TLS recommendations]: https://wiki.mozilla.org/Security/Server_Side_TLS
-[asn1.js]: https://npmjs.org/package/asn1.js
+[asn1.js]: https://www.npmjs.com/package/asn1.js
 [modifying the default cipher suite]: #tls_modifying_the_default_tls_cipher_suite
 [specific attacks affecting larger AES key sizes]: https://www.schneier.com/blog/archives/2009/07/another_new_aes.html
diff --git a/doc/api/util.md b/doc/api/util.md
index 3352a28a866289..e054c8a35bc7d7 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -2137,6 +2137,6 @@ Deprecated predecessor of `console.log`.
 [Module Namespace Object]: https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects
 [WHATWG Encoding Standard]: https://encoding.spec.whatwg.org/
 [Common System Errors]: errors.html#errors_common_system_errors
-[constructor]: https://developer.mozilla.org/en-US/JavaScript/Reference/Global_Objects/Object/constructor
+[constructor]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor
 [list of deprecated APIS]: deprecations.html#deprecations_list_of_deprecated_apis
 [semantically incompatible]: https://github.com/nodejs/node/issues/4179
diff --git a/doc/api/v8.md b/doc/api/v8.md
index c5d23af7a3154a..c9afa93f89d4ec 100644
--- a/doc/api/v8.md
+++ b/doc/api/v8.md
@@ -413,4 +413,4 @@ A subclass of [`Deserializer`][] corresponding to the format written by
 [V8]: https://developers.google.com/v8/
 [`vm.Script`]: vm.html#vm_new_vm_script_code_options
 [here]: https://github.com/thlorenz/v8-flags/blob/master/flags-0.11.md
-[`GetHeapSpaceStatistics`]: https://v8docs.nodesource.com/node-8.0/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4
+[`GetHeapSpaceStatistics`]: https://v8docs.nodesource.com/node-8.9/d5/dda/classv8_1_1_isolate.html#ac673576f24fdc7a33378f8f57e1d13a4

From ca8c96035ae775d72605a7dbf2827ae4d086c23e Mon Sep 17 00:00:00 2001
From: Lance Ball <lball@redhat.com>
Date: Sun, 15 Jul 2018 02:45:11 +0100
Subject: [PATCH 083/116] doc: update readme with my pronouns
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21818
Refs: https://github.com/nodejs/node/issues/21803
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Shelley Vohr <codebytere@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e81f6629ed342a..c899b1a9a9b400 100644
--- a/README.md
+++ b/README.md
@@ -422,7 +422,7 @@ For more information about the governance of the Node.js project, see
 * [kunalspathak](https://github.com/kunalspathak) -
 **Kunal Pathak** &lt;kunal.pathak@microsoft.com&gt;
 * [lance](https://github.com/lance) -
-**Lance Ball** &lt;lball@redhat.com&gt;
+**Lance Ball** &lt;lball@redhat.com&gt; (he/him)
 * [Leko](https://github.com/Leko) -
 **Shingo Inoue** &lt;leko.noor@gmail.com&gt; (he/him)
 * [lpinca](https://github.com/lpinca) -

From 678313d18b77146573c2202078e76b3bd6d64a78 Mon Sep 17 00:00:00 2001
From: Masashi Hirano <cherrydog07@gmail.com>
Date: Sat, 5 May 2018 11:38:09 +0900
Subject: [PATCH 084/116] test: add filehandle sync() and datasync() tests

To increase test coverage for fs.promises,
added tests for filehandle.sync and filehandle.datasync.

PR-URL: https://github.com/nodejs/node/pull/20530
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 .../test-fs-promises-file-handle-sync.js      | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 test/parallel/test-fs-promises-file-handle-sync.js

diff --git a/test/parallel/test-fs-promises-file-handle-sync.js b/test/parallel/test-fs-promises-file-handle-sync.js
new file mode 100644
index 00000000000000..cf28df31cb2e0f
--- /dev/null
+++ b/test/parallel/test-fs-promises-file-handle-sync.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+const { access, copyFile, open } = require('fs').promises;
+const path = require('path');
+
+common.crashOnUnhandledRejection();
+
+async function validateSync() {
+  tmpdir.refresh();
+  const dest = path.resolve(tmpdir.path, 'baz.js');
+  await copyFile(fixtures.path('baz.js'), dest);
+  await access(dest, 'r');
+  const handle = await open(dest, 'r+');
+  await handle.datasync();
+  await handle.sync();
+  const buf = Buffer.from('hello world');
+  await handle.write(buf);
+  const ret = await handle.read(Buffer.alloc(11), 0, 11, 0);
+  assert.strictEqual(ret.bytesRead, 11);
+  assert.deepStrictEqual(ret.buffer, buf);
+}
+
+validateSync();

From 02982998db080ed808d3762c62994b775a94ced7 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Sat, 14 Jul 2018 17:15:32 +0200
Subject: [PATCH 085/116] doc: add my pronoun
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21813
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c899b1a9a9b400..ce03c7d4c04269 100644
--- a/README.md
+++ b/README.md
@@ -332,7 +332,7 @@ For more information about the governance of the Node.js project, see
 * [brendanashworth](https://github.com/brendanashworth) -
 **Brendan Ashworth** &lt;brendan.ashworth@me.com&gt;
 * [BridgeAR](https://github.com/BridgeAR) -
-**Ruben Bridgewater** &lt;ruben@bridgewater.de&gt;
+**Ruben Bridgewater** &lt;ruben@bridgewater.de&gt; (he/him)
 * [bzoz](https://github.com/bzoz) -
 **Bartosz Sosnowski** &lt;bartosz@janeasystems.com&gt;
 * [calvinmetcalf](https://github.com/calvinmetcalf) -

From d42dbde1a8f1e373ea9ed24cf7e0addadac58af3 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sun, 10 Jun 2018 15:57:46 +0200
Subject: [PATCH 086/116] src: add iteration over all base objects to
 Environment

PR-URL: https://github.com/nodejs/node/pull/21741
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 src/env-inl.h | 16 ++++++++++++++++
 src/env.h     |  5 +++++
 2 files changed, 21 insertions(+)

diff --git a/src/env-inl.h b/src/env-inl.h
index b436b23b678015..4ef9665cbddfed 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -809,6 +809,22 @@ bool Environment::CleanupHookCallback::Equal::operator()(
   return a.fn_ == b.fn_ && a.arg_ == b.arg_;
 }
 
+BaseObject* Environment::CleanupHookCallback::GetBaseObject() const {
+  if (fn_ == BaseObject::DeleteMe)
+    return static_cast<BaseObject*>(arg_);
+  else
+    return nullptr;
+}
+
+template <typename T>
+void Environment::ForEachBaseObject(T&& iterator) {
+  for (const auto& hook : cleanup_hooks_) {
+    BaseObject* obj = hook.GetBaseObject();
+    if (obj != nullptr)
+      iterator(obj);
+  }
+}
+
 #define VP(PropertyName, StringValue) V(v8::Private, PropertyName)
 #define VY(PropertyName, StringValue) V(v8::Symbol, PropertyName)
 #define VS(PropertyName, StringValue) V(v8::String, PropertyName)
diff --git a/src/env.h b/src/env.h
index ea50d019c2327f..3f4ea83b5611fd 100644
--- a/src/env.h
+++ b/src/env.h
@@ -976,6 +976,8 @@ class Environment {
       inline bool operator()(const CleanupHookCallback& a,
                              const CleanupHookCallback& b) const;
     };
+
+    inline BaseObject* GetBaseObject() const;
   };
 
   // Use an unordered_set, so that we have efficient insertion and removal.
@@ -988,6 +990,9 @@ class Environment {
                              v8::Local<v8::Promise> promise,
                              v8::Local<v8::Value> parent);
 
+  template <typename T>
+  void ForEachBaseObject(T&& iterator);
+
 #define V(PropertyName, TypeName) Persistent<TypeName> PropertyName ## _;
   ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
 #undef V

From 355c5e3c955cf9f5ad4a2cfcdebbc7db2f945c9a Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 30 Jun 2018 21:09:21 +0200
Subject: [PATCH 087/116] deps: cherry-pick 555c811 from upstream V8

Original commit message:

    [api] Switch from `SetBuildEmbedderGraphCallback` to `AddBuildEmbedderGraphCallback`

    `SetBuildEmbedderGraphCallback`, unlike `SetWrapperClassInfoProvider`,
    assumes a monolithic embedder that can provide all necessary information.
    That is not the case for e.g. Node.js, which can e.g. provide multiple Node.js
    instances per V8 Isolate, as well as native addons that may allocate resources
    on their own.

    Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng
    Change-Id: Ib53dfde82416dd69934b08623e27d674a483ac2d
    Reviewed-on: https://chromium-review.googlesource.com/1082441
    Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
    Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
    Reviewed-by: Yang Guo <yangguo@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#53545}

Refs: https://github.com/v8/v8/commit/555c811c0d44d9aaaccf8e76059ed24537b3f012

PR-URL: https://github.com/nodejs/node/pull/21741
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 common.gypi                               |   2 +-
 deps/v8/include/v8-profiler.h             |  22 +++--
 deps/v8/src/api.cc                        |  22 ++++-
 deps/v8/src/profiler/heap-profiler.cc     |  21 +++--
 deps/v8/src/profiler/heap-profiler.h      |  12 +--
 deps/v8/test/cctest/test-heap-profiler.cc | 104 +++++++++++++++++++---
 6 files changed, 152 insertions(+), 31 deletions(-)

diff --git a/common.gypi b/common.gypi
index 9d74b46a8d5c70..a782cfbecb85e2 100644
--- a/common.gypi
+++ b/common.gypi
@@ -28,7 +28,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.14',
+    'v8_embedder_string': '-node.15',
 
     # Enable disassembler for `--print-code` v8 options
     'v8_enable_disassembler': 1,
diff --git a/deps/v8/include/v8-profiler.h b/deps/v8/include/v8-profiler.h
index 5df9b2a217ea8e..c61027b3b94e45 100644
--- a/deps/v8/include/v8-profiler.h
+++ b/deps/v8/include/v8-profiler.h
@@ -636,7 +636,7 @@ class V8_EXPORT AllocationProfile {
  * Usage:
  * 1) Define derived class of EmbedderGraph::Node for embedder objects.
  * 2) Set the build embedder graph callback on the heap profiler using
- *    HeapProfiler::SetBuildEmbedderGraphCallback.
+ *    HeapProfiler::AddBuildEmbedderGraphCallback.
  * 3) In the callback use graph->AddEdge(node1, node2) to add an edge from
  *    node1 to node2.
  * 4) To represent references from/to V8 object, construct V8 nodes using
@@ -736,7 +736,12 @@ class V8_EXPORT HeapProfiler {
    * The callback must not trigger garbage collection in V8.
    */
   typedef void (*BuildEmbedderGraphCallback)(v8::Isolate* isolate,
-                                             v8::EmbedderGraph* graph);
+                                             v8::EmbedderGraph* graph,
+                                             void* data);
+
+  /** TODO(addaleax): Remove */
+  typedef void (*LegacyBuildEmbedderGraphCallback)(v8::Isolate* isolate,
+                                                   v8::EmbedderGraph* graph);
 
   /** Returns the number of snapshots taken. */
   int GetSnapshotCount();
@@ -878,15 +883,22 @@ class V8_EXPORT HeapProfiler {
 
   /** Binds a callback to embedder's class ID. */
   V8_DEPRECATED(
-      "Use SetBuildEmbedderGraphCallback to provide info about embedder nodes",
+      "Use AddBuildEmbedderGraphCallback to provide info about embedder nodes",
       void SetWrapperClassInfoProvider(uint16_t class_id,
                                        WrapperInfoCallback callback));
 
   V8_DEPRECATED(
-      "Use SetBuildEmbedderGraphCallback to provide info about embedder nodes",
+      "Use AddBuildEmbedderGraphCallback to provide info about embedder nodes",
       void SetGetRetainerInfosCallback(GetRetainerInfosCallback callback));
 
-  void SetBuildEmbedderGraphCallback(BuildEmbedderGraphCallback callback);
+  V8_DEPRECATE_SOON(
+      "Use AddBuildEmbedderGraphCallback to provide info about embedder nodes",
+      void SetBuildEmbedderGraphCallback(
+          LegacyBuildEmbedderGraphCallback callback));
+  void AddBuildEmbedderGraphCallback(BuildEmbedderGraphCallback callback,
+                                     void* data);
+  void RemoveBuildEmbedderGraphCallback(BuildEmbedderGraphCallback callback,
+                                        void* data);
 
   /**
    * Default value of persistent handle class ID. Must not be used to
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc
index a7f6d00f6fabf7..192ad90f83e55c 100644
--- a/deps/v8/src/api.cc
+++ b/deps/v8/src/api.cc
@@ -10558,9 +10558,25 @@ void HeapProfiler::SetGetRetainerInfosCallback(
 }
 
 void HeapProfiler::SetBuildEmbedderGraphCallback(
-    BuildEmbedderGraphCallback callback) {
-  reinterpret_cast<i::HeapProfiler*>(this)->SetBuildEmbedderGraphCallback(
-      callback);
+    LegacyBuildEmbedderGraphCallback callback) {
+  reinterpret_cast<i::HeapProfiler*>(this)->AddBuildEmbedderGraphCallback(
+      [](v8::Isolate* isolate, v8::EmbedderGraph* graph, void* data) {
+        reinterpret_cast<LegacyBuildEmbedderGraphCallback>(data)(isolate,
+                                                                 graph);
+      },
+      reinterpret_cast<void*>(callback));
+}
+
+void HeapProfiler::AddBuildEmbedderGraphCallback(
+    BuildEmbedderGraphCallback callback, void* data) {
+  reinterpret_cast<i::HeapProfiler*>(this)->AddBuildEmbedderGraphCallback(
+      callback, data);
+}
+
+void HeapProfiler::RemoveBuildEmbedderGraphCallback(
+    BuildEmbedderGraphCallback callback, void* data) {
+  reinterpret_cast<i::HeapProfiler*>(this)->RemoveBuildEmbedderGraphCallback(
+      callback, data);
 }
 
 v8::Testing::StressType internal::Testing::stress_type_ =
diff --git a/deps/v8/src/profiler/heap-profiler.cc b/deps/v8/src/profiler/heap-profiler.cc
index 7e0bcec97ae75e..2496e24b91cf18 100644
--- a/deps/v8/src/profiler/heap-profiler.cc
+++ b/deps/v8/src/profiler/heap-profiler.cc
@@ -69,16 +69,25 @@ v8::HeapProfiler::RetainerInfos HeapProfiler::GetRetainerInfos(
   return infos;
 }
 
-void HeapProfiler::SetBuildEmbedderGraphCallback(
-    v8::HeapProfiler::BuildEmbedderGraphCallback callback) {
-  build_embedder_graph_callback_ = callback;
+void HeapProfiler::AddBuildEmbedderGraphCallback(
+    v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data) {
+  build_embedder_graph_callbacks_.push_back({callback, data});
+}
+
+void HeapProfiler::RemoveBuildEmbedderGraphCallback(
+    v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data) {
+  auto it = std::find(build_embedder_graph_callbacks_.begin(),
+                      build_embedder_graph_callbacks_.end(),
+                      std::make_pair(callback, data));
+  if (it != build_embedder_graph_callbacks_.end())
+    build_embedder_graph_callbacks_.erase(it);
 }
 
 void HeapProfiler::BuildEmbedderGraph(Isolate* isolate,
                                       v8::EmbedderGraph* graph) {
-  if (build_embedder_graph_callback_ != nullptr)
-    build_embedder_graph_callback_(reinterpret_cast<v8::Isolate*>(isolate),
-                                   graph);
+  for (const auto& cb : build_embedder_graph_callbacks_) {
+    cb.first(reinterpret_cast<v8::Isolate*>(isolate), graph, cb.second);
+  }
 }
 
 HeapSnapshot* HeapProfiler::TakeSnapshot(
diff --git a/deps/v8/src/profiler/heap-profiler.h b/deps/v8/src/profiler/heap-profiler.h
index 507dd579bffb65..fc0b005e1c67ce 100644
--- a/deps/v8/src/profiler/heap-profiler.h
+++ b/deps/v8/src/profiler/heap-profiler.h
@@ -71,11 +71,13 @@ class HeapProfiler : public HeapObjectAllocationTracker {
       v8::HeapProfiler::GetRetainerInfosCallback callback);
   v8::HeapProfiler::RetainerInfos GetRetainerInfos(Isolate* isolate);
 
-  void SetBuildEmbedderGraphCallback(
-      v8::HeapProfiler::BuildEmbedderGraphCallback callback);
+  void AddBuildEmbedderGraphCallback(
+      v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data);
+  void RemoveBuildEmbedderGraphCallback(
+      v8::HeapProfiler::BuildEmbedderGraphCallback callback, void* data);
   void BuildEmbedderGraph(Isolate* isolate, v8::EmbedderGraph* graph);
   bool HasBuildEmbedderGraphCallback() {
-    return build_embedder_graph_callback_ != nullptr;
+    return !build_embedder_graph_callbacks_.empty();
   }
 
   bool is_tracking_object_moves() const { return is_tracking_object_moves_; }
@@ -103,8 +105,8 @@ class HeapProfiler : public HeapObjectAllocationTracker {
   std::unique_ptr<SamplingHeapProfiler> sampling_heap_profiler_;
   v8::HeapProfiler::GetRetainerInfosCallback get_retainer_infos_callback_ =
       nullptr;
-  v8::HeapProfiler::BuildEmbedderGraphCallback build_embedder_graph_callback_ =
-      nullptr;
+  std::vector<std::pair<v8::HeapProfiler::BuildEmbedderGraphCallback, void*>>
+      build_embedder_graph_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(HeapProfiler);
 };
diff --git a/deps/v8/test/cctest/test-heap-profiler.cc b/deps/v8/test/cctest/test-heap-profiler.cc
index 4372aa3d2e5205..eec739d109dcf1 100644
--- a/deps/v8/test/cctest/test-heap-profiler.cc
+++ b/deps/v8/test/cctest/test-heap-profiler.cc
@@ -1541,8 +1541,8 @@ class EmbedderGraphBuilder : public v8::PersistentHandleVisitor {
         graph->AddNode(std::unique_ptr<Group>(new Group("ccc-group")));
   }
 
-  static void BuildEmbedderGraph(v8::Isolate* isolate,
-                                 v8::EmbedderGraph* graph) {
+  static void BuildEmbedderGraph(v8::Isolate* isolate, v8::EmbedderGraph* graph,
+                                 void* data) {
     EmbedderGraphBuilder builder(isolate, graph);
     isolate->VisitHandlesWithClassIds(&builder);
   }
@@ -1604,8 +1604,8 @@ TEST(HeapSnapshotRetainedObjectInfo) {
   v8::HandleScope scope(isolate);
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
 
-  heap_profiler->SetBuildEmbedderGraphCallback(
-      EmbedderGraphBuilder::BuildEmbedderGraph);
+  heap_profiler->AddBuildEmbedderGraphCallback(
+      EmbedderGraphBuilder::BuildEmbedderGraph, nullptr);
   v8::Persistent<v8::String> p_AAA(isolate, v8_str("AAA"));
   p_AAA.SetWrapperClassId(1);
   v8::Persistent<v8::String> p_BBB(isolate, v8_str("BBB"));
@@ -2932,7 +2932,8 @@ class EmbedderRootNode : public EmbedderNode {
 // global object.
 v8::Local<v8::Value>* global_object_pointer;
 
-void BuildEmbedderGraph(v8::Isolate* v8_isolate, v8::EmbedderGraph* graph) {
+void BuildEmbedderGraph(v8::Isolate* v8_isolate, v8::EmbedderGraph* graph,
+                        void* data) {
   using Node = v8::EmbedderGraph::Node;
   Node* global_node = graph->V8Node(*global_object_pointer);
   Node* embedder_node_A = graph->AddNode(
@@ -2979,12 +2980,92 @@ TEST(EmbedderGraph) {
           (isolate->context()->native_context()->global_object())));
   global_object_pointer = &global_object;
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
-  heap_profiler->SetBuildEmbedderGraphCallback(BuildEmbedderGraph);
+  heap_profiler->AddBuildEmbedderGraphCallback(BuildEmbedderGraph, nullptr);
   const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
   CHECK(ValidateSnapshot(snapshot));
   CheckEmbedderGraphSnapshot(env->GetIsolate(), snapshot);
 }
 
+struct GraphBuildingContext {
+  int counter = 0;
+};
+
+void CheckEmbedderGraphSnapshotWithContext(
+    v8::Isolate* isolate, const v8::HeapSnapshot* snapshot,
+    const GraphBuildingContext* context) {
+  const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
+  CHECK_GE(context->counter, 1);
+  CHECK_LE(context->counter, 2);
+
+  const v8::HeapGraphNode* embedder_node_A =
+      GetChildByName(global, "EmbedderNodeA");
+  CHECK_EQ(10, GetSize(embedder_node_A));
+
+  const v8::HeapGraphNode* embedder_node_B =
+      GetChildByName(global, "EmbedderNodeB");
+  if (context->counter == 2) {
+    CHECK_NOT_NULL(embedder_node_B);
+    CHECK_EQ(20, GetSize(embedder_node_B));
+  } else {
+    CHECK_NULL(embedder_node_B);
+  }
+}
+
+void BuildEmbedderGraphWithContext(v8::Isolate* v8_isolate,
+                                   v8::EmbedderGraph* graph, void* data) {
+  using Node = v8::EmbedderGraph::Node;
+  GraphBuildingContext* context = static_cast<GraphBuildingContext*>(data);
+  Node* global_node = graph->V8Node(*global_object_pointer);
+
+  CHECK_GE(context->counter, 0);
+  CHECK_LE(context->counter, 1);
+  switch (context->counter++) {
+    case 0: {
+      Node* embedder_node_A = graph->AddNode(
+          std::unique_ptr<Node>(new EmbedderNode("EmbedderNodeA", 10)));
+      graph->AddEdge(global_node, embedder_node_A);
+      break;
+    }
+    case 1: {
+      Node* embedder_node_B = graph->AddNode(
+          std::unique_ptr<Node>(new EmbedderNode("EmbedderNodeB", 20)));
+      graph->AddEdge(global_node, embedder_node_B);
+      break;
+    }
+  }
+}
+
+TEST(EmbedderGraphMultipleCallbacks) {
+  i::FLAG_heap_profiler_use_embedder_graph = true;
+  LocalContext env;
+  v8::HandleScope scope(env->GetIsolate());
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
+  v8::Local<v8::Value> global_object =
+      v8::Utils::ToLocal(i::Handle<i::JSObject>(
+          (isolate->context()->native_context()->global_object())));
+  global_object_pointer = &global_object;
+  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
+  GraphBuildingContext context;
+
+  heap_profiler->AddBuildEmbedderGraphCallback(BuildEmbedderGraphWithContext,
+                                               &context);
+  heap_profiler->AddBuildEmbedderGraphCallback(BuildEmbedderGraphWithContext,
+                                               &context);
+  const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
+  CHECK_EQ(context.counter, 2);
+  CHECK(ValidateSnapshot(snapshot));
+  CheckEmbedderGraphSnapshotWithContext(env->GetIsolate(), snapshot, &context);
+
+  heap_profiler->RemoveBuildEmbedderGraphCallback(BuildEmbedderGraphWithContext,
+                                                  &context);
+  context.counter = 0;
+
+  snapshot = heap_profiler->TakeHeapSnapshot();
+  CHECK_EQ(context.counter, 1);
+  CHECK(ValidateSnapshot(snapshot));
+  CheckEmbedderGraphSnapshotWithContext(env->GetIsolate(), snapshot, &context);
+}
+
 TEST(StrongHandleAnnotation) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
@@ -3010,7 +3091,7 @@ TEST(StrongHandleAnnotation) {
 }
 
 void BuildEmbedderGraphWithWrapperNode(v8::Isolate* v8_isolate,
-                                       v8::EmbedderGraph* graph) {
+                                       v8::EmbedderGraph* graph, void* data) {
   using Node = v8::EmbedderGraph::Node;
   Node* global_node = graph->V8Node(*global_object_pointer);
   Node* wrapper_node = graph->AddNode(
@@ -3041,8 +3122,8 @@ TEST(EmbedderGraphWithWrapperNode) {
           (isolate->context()->native_context()->global_object())));
   global_object_pointer = &global_object;
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
-  heap_profiler->SetBuildEmbedderGraphCallback(
-      BuildEmbedderGraphWithWrapperNode);
+  heap_profiler->AddBuildEmbedderGraphCallback(
+      BuildEmbedderGraphWithWrapperNode, nullptr);
   const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
@@ -3080,7 +3161,7 @@ class EmbedderNodeWithPrefix : public v8::EmbedderGraph::Node {
 };
 
 void BuildEmbedderGraphWithPrefix(v8::Isolate* v8_isolate,
-                                  v8::EmbedderGraph* graph) {
+                                  v8::EmbedderGraph* graph, void* data) {
   using Node = v8::EmbedderGraph::Node;
   Node* global_node = graph->V8Node(*global_object_pointer);
   Node* node = graph->AddNode(
@@ -3098,7 +3179,8 @@ TEST(EmbedderGraphWithPrefix) {
           (isolate->context()->native_context()->global_object())));
   global_object_pointer = &global_object;
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
-  heap_profiler->SetBuildEmbedderGraphCallback(BuildEmbedderGraphWithPrefix);
+  heap_profiler->AddBuildEmbedderGraphCallback(BuildEmbedderGraphWithPrefix,
+                                               nullptr);
   const v8::HeapSnapshot* snapshot = heap_profiler->TakeHeapSnapshot();
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);

From 5121278f5ce28b85d6f9b0d85fcfc42e89a13093 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Wed, 11 Jul 2018 00:59:53 +0200
Subject: [PATCH 088/116] src: use V8 graph heap snapshot API

Transition to a newer, more flexible API for
heap snapshot creation.

This addresses a currently pending deprecation in the V8 API.

PR-URL: https://github.com/nodejs/node/pull/21741
Fixes: https://github.com/nodejs/node/issues/21633
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 src/async_wrap.cc        | 100 ++-----------------------------------
 src/async_wrap.h         |   3 +-
 src/env.cc               |  17 ++++++-
 src/env.h                |   4 ++
 src/memory_tracker-inl.h | 105 ++++++++++++++++++++++++++++++++++++---
 src/memory_tracker.h     |  35 ++++++++++---
 src/tls_wrap.cc          |   8 ++-
 src/tls_wrap.h           |   4 +-
 8 files changed, 160 insertions(+), 116 deletions(-)

diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index e98dca3c56651b..7ef3dafdf992c5 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -32,7 +32,6 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
-using v8::HeapProfiler;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
@@ -43,7 +42,6 @@ using v8::ObjectTemplate;
 using v8::Promise;
 using v8::PromiseHookType;
 using v8::PropertyCallbackInfo;
-using v8::RetainedObjectInfo;
 using v8::String;
 using v8::Uint32;
 using v8::Undefined;
@@ -61,87 +59,6 @@ static const char* const provider_names[] = {
 };
 
 
-// Report correct information in a heapdump.
-
-class RetainedAsyncInfo: public RetainedObjectInfo {
- public:
-  explicit RetainedAsyncInfo(uint16_t class_id, AsyncWrap* wrap);
-
-  void Dispose() override;
-  bool IsEquivalent(RetainedObjectInfo* other) override;
-  intptr_t GetHash() override;
-  const char* GetLabel() override;
-  intptr_t GetSizeInBytes() override;
-
- private:
-  const char* label_;
-  const AsyncWrap* wrap_;
-  const size_t length_;
-};
-
-
-static int OwnMemory(AsyncWrap* async_wrap) {
-  MemoryTracker tracker;
-  tracker.set_track_only_self(true);
-  tracker.Track(async_wrap);
-  return tracker.accumulated_size();
-}
-
-
-RetainedAsyncInfo::RetainedAsyncInfo(uint16_t class_id, AsyncWrap* wrap)
-    : label_(provider_names[class_id - NODE_ASYNC_ID_OFFSET]),
-      wrap_(wrap),
-      length_(OwnMemory(wrap)) {
-}
-
-
-void RetainedAsyncInfo::Dispose() {
-  delete this;
-}
-
-
-bool RetainedAsyncInfo::IsEquivalent(RetainedObjectInfo* other) {
-  return label_ == other->GetLabel() &&
-          wrap_ == static_cast<RetainedAsyncInfo*>(other)->wrap_;
-}
-
-
-intptr_t RetainedAsyncInfo::GetHash() {
-  return reinterpret_cast<intptr_t>(wrap_);
-}
-
-
-const char* RetainedAsyncInfo::GetLabel() {
-  return label_;
-}
-
-
-intptr_t RetainedAsyncInfo::GetSizeInBytes() {
-  return length_;
-}
-
-
-RetainedObjectInfo* WrapperInfo(uint16_t class_id, Local<Value> wrapper) {
-  // No class_id should be the provider type of NONE.
-  CHECK_GT(class_id, NODE_ASYNC_ID_OFFSET);
-  // And make sure the class_id doesn't extend past the last provider.
-  CHECK_LE(class_id - NODE_ASYNC_ID_OFFSET, AsyncWrap::PROVIDERS_LENGTH);
-  CHECK(wrapper->IsObject());
-  CHECK(!wrapper.IsEmpty());
-
-  Local<Object> object = wrapper.As<Object>();
-  CHECK_GT(object->InternalFieldCount(), 0);
-
-  AsyncWrap* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap, object, nullptr);
-
-  return new RetainedAsyncInfo(class_id, wrap);
-}
-
-
-// end RetainedAsyncInfo
-
-
 struct AsyncWrapObject : public AsyncWrap {
   static inline void New(const FunctionCallbackInfo<Value>& args) {
     Environment* env = Environment::GetCurrent(args);
@@ -616,16 +533,6 @@ void AsyncWrap::Initialize(Local<Object> target,
 }
 
 
-void LoadAsyncWrapperInfo(Environment* env) {
-  HeapProfiler* heap_profiler = env->isolate()->GetHeapProfiler();
-#define V(PROVIDER)                                                           \
-  heap_profiler->SetWrapperClassInfoProvider(                                 \
-      (NODE_ASYNC_ID_OFFSET + AsyncWrap::PROVIDER_ ## PROVIDER), WrapperInfo);
-  NODE_ASYNC_PROVIDER_TYPES(V)
-#undef V
-}
-
-
 AsyncWrap::AsyncWrap(Environment* env,
                      Local<Object> object,
                      ProviderType provider,
@@ -814,9 +721,12 @@ void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
       Environment::GetCurrent(isolate), asyncContext.async_id);
 }
 
+std::string AsyncWrap::MemoryInfoName() const {
+  return provider_names[provider_type()];
+}
+
 std::string AsyncWrap::diagnostic_name() const {
-  return std::string(provider_names[provider_type()]) +
-      " (" + std::to_string(env()->thread_id()) + ":" +
+  return MemoryInfoName() + " (" + std::to_string(env()->thread_id()) + ":" +
       std::to_string(static_cast<int64_t>(async_id_)) + ")";
 }
 
diff --git a/src/async_wrap.h b/src/async_wrap.h
index c1d90f8fad0541..e61837af61c242 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -175,6 +175,7 @@ class AsyncWrap : public BaseObject {
       v8::Local<v8::Value>* argv);
 
   virtual std::string diagnostic_name() const;
+  std::string MemoryInfoName() const override;
 
   static void WeakCallback(const v8::WeakCallbackInfo<DestroyParam> &info);
 
@@ -205,8 +206,6 @@ class AsyncWrap : public BaseObject {
   double trigger_async_id_;
 };
 
-void LoadAsyncWrapperInfo(Environment* env);
-
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/env.cc b/src/env.cc
index 006173eaaeb847..3d1a9372c93c7d 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -142,9 +142,15 @@ Environment::Environment(IsolateData* isolate_data,
   std::string debug_cats;
   SafeGetenv("NODE_DEBUG_NATIVE", &debug_cats);
   set_debug_categories(debug_cats, true);
+
+  isolate()->GetHeapProfiler()->AddBuildEmbedderGraphCallback(
+      BuildEmbedderGraph, this);
 }
 
 Environment::~Environment() {
+  isolate()->GetHeapProfiler()->RemoveBuildEmbedderGraphCallback(
+      BuildEmbedderGraph, this);
+
   // Make sure there are no re-used libuv wrapper objects.
   // CleanupHandles() should have removed all of them.
   CHECK(file_handle_read_wrap_freelist_.empty());
@@ -212,7 +218,6 @@ void Environment::Start(int argc,
   set_process_object(process_object);
 
   SetupProcessObject(this, argc, argv, exec_argc, exec_argv);
-  LoadAsyncWrapperInfo(this);
 
   static uv_once_t init_once = UV_ONCE_INIT;
   uv_once(&init_once, InitThreadLocalOnce);
@@ -653,6 +658,16 @@ void Environment::stop_sub_worker_contexts() {
   }
 }
 
+void Environment::BuildEmbedderGraph(v8::Isolate* isolate,
+                                     v8::EmbedderGraph* graph,
+                                     void* data) {
+  MemoryTracker tracker(isolate, graph);
+  static_cast<Environment*>(data)->ForEachBaseObject([&](BaseObject* obj) {
+    tracker.Track(obj);
+  });
+}
+
+
 // Not really any better place than env.cc at this moment.
 void BaseObject::DeleteMe(void* data) {
   BaseObject* self = static_cast<BaseObject*>(data);
diff --git a/src/env.h b/src/env.h
index 3f4ea83b5611fd..9c7f4d1ba8ae3f 100644
--- a/src/env.h
+++ b/src/env.h
@@ -859,6 +859,10 @@ class Environment {
   inline void RemoveCleanupHook(void (*fn)(void*), void* arg);
   void RunCleanup();
 
+  static void BuildEmbedderGraph(v8::Isolate* isolate,
+                                 v8::EmbedderGraph* graph,
+                                 void* data);
+
  private:
   inline void CreateImmediate(native_immediate_callback cb,
                               void* data,
diff --git a/src/memory_tracker-inl.h b/src/memory_tracker-inl.h
index 758223492f6e71..568a4364f9c64d 100644
--- a/src/memory_tracker-inl.h
+++ b/src/memory_tracker-inl.h
@@ -7,13 +7,54 @@
 
 namespace node {
 
+class MemoryRetainerNode : public v8::EmbedderGraph::Node {
+ public:
+  explicit inline MemoryRetainerNode(MemoryTracker* tracker,
+                                     const MemoryRetainer* retainer,
+                                     const char* name)
+     : retainer_(retainer) {
+    if (retainer_ != nullptr) {
+      v8::HandleScope handle_scope(tracker->isolate());
+      v8::Local<v8::Object> obj = retainer_->WrappedObject();
+      if (!obj.IsEmpty())
+        wrapper_node_ = tracker->graph()->V8Node(obj);
+
+      name_ = retainer_->MemoryInfoName();
+    }
+    if (name_.empty() && name != nullptr) {
+      name_ = name;
+    }
+  }
+
+  const char* Name() override { return name_.c_str(); }
+  const char* NamePrefix() override { return "Node /"; }
+  size_t SizeInBytes() override { return size_; }
+  // TODO(addaleax): Merging this with the "official" WrapperNode() method
+  // seems to lose accuracy, e.g. SizeInBytes() is disregarded.
+  // Figure out whether to do anything about that.
+  Node* JSWrapperNode() { return wrapper_node_; }
+
+  bool IsRootNode() override {
+    return retainer_ != nullptr && retainer_->IsRootNode();
+  }
+
+ private:
+  friend class MemoryTracker;
+
+  Node* wrapper_node_ = nullptr;
+  const MemoryRetainer* retainer_;
+  std::string name_;
+  size_t size_ = 0;
+};
+
 template <typename T>
 void MemoryTracker::TrackThis(const T* obj) {
-  accumulated_size_ += sizeof(T);
+  CurrentNode()->size_ = sizeof(T);
 }
 
 void MemoryTracker::TrackFieldWithSize(const char* name, size_t size) {
-  accumulated_size_ += size;
+  if (size > 0)
+    AddNode(name)->size_ = size;
 }
 
 void MemoryTracker::TrackField(const char* name, const MemoryRetainer& value) {
@@ -21,9 +62,13 @@ void MemoryTracker::TrackField(const char* name, const MemoryRetainer& value) {
 }
 
 void MemoryTracker::TrackField(const char* name, const MemoryRetainer* value) {
-  if (track_only_self_ || value == nullptr || seen_.count(value) > 0) return;
-  seen_.insert(value);
-  Track(value);
+  if (track_only_self_ || value == nullptr) return;
+  auto it = seen_.find(value);
+  if (it != seen_.end()) {
+    graph_->AddEdge(CurrentNode(), it->second);
+  } else {
+    Track(value, name);
+  }
 }
 
 template <typename T>
@@ -36,8 +81,10 @@ template <typename T, typename Iterator>
 void MemoryTracker::TrackField(const char* name, const T& value) {
   if (value.begin() == value.end()) return;
   size_t index = 0;
+  PushNode(name);
   for (Iterator it = value.begin(); it != value.end(); ++it)
     TrackField(std::to_string(index++).c_str(), *it);
+  PopNode();
 }
 
 template <typename T>
@@ -56,13 +103,15 @@ void MemoryTracker::TrackField(const char* name, const std::queue<T>& value) {
 template <typename T, typename test_for_number, typename dummy>
 void MemoryTracker::TrackField(const char* name, const T& value) {
   // For numbers, creating new nodes is not worth the overhead.
-  TrackFieldWithSize(name, sizeof(T));
+  CurrentNode()->size_ += sizeof(T);
 }
 
 template <typename T, typename U>
 void MemoryTracker::TrackField(const char* name, const std::pair<T, U>& value) {
+  PushNode(name);
   TrackField("first", value.first);
   TrackField("second", value.second);
+  PopNode();
 }
 
 template <typename T>
@@ -74,10 +123,13 @@ void MemoryTracker::TrackField(const char* name,
 template <typename T, typename Traits>
 void MemoryTracker::TrackField(const char* name,
                                const v8::Persistent<T, Traits>& value) {
+  TrackField(name, value.Get(isolate_));
 }
 
 template <typename T>
 void MemoryTracker::TrackField(const char* name, const v8::Local<T>& value) {
+  if (!value.IsEmpty())
+    graph_->AddEdge(CurrentNode(), graph_->V8Node(value));
 }
 
 template <typename T>
@@ -96,8 +148,47 @@ void MemoryTracker::TrackField(const char* name,
   TrackField(name, value.GetJSArray());
 }
 
-void MemoryTracker::Track(const MemoryRetainer* value) {
+void MemoryTracker::Track(const MemoryRetainer* value, const char* name) {
+  v8::HandleScope handle_scope(isolate_);
+  MemoryRetainerNode* n = PushNode(name, value);
   value->MemoryInfo(this);
+  CHECK_EQ(CurrentNode(), n);
+  CHECK_NE(n->size_, 0);
+  PopNode();
+}
+
+MemoryRetainerNode* MemoryTracker::CurrentNode() const {
+  if (node_stack_.empty()) return nullptr;
+  return node_stack_.top();
+}
+
+MemoryRetainerNode* MemoryTracker::AddNode(
+    const char* name, const MemoryRetainer* retainer) {
+  MemoryRetainerNode* n = new MemoryRetainerNode(this, retainer, name);
+  graph_->AddNode(std::unique_ptr<v8::EmbedderGraph::Node>(n));
+  if (retainer != nullptr)
+    seen_[retainer] = n;
+
+  if (CurrentNode() != nullptr)
+    graph_->AddEdge(CurrentNode(), n);
+
+  if (n->JSWrapperNode() != nullptr) {
+    graph_->AddEdge(n, n->JSWrapperNode());
+    graph_->AddEdge(n->JSWrapperNode(), n);
+  }
+
+  return n;
+}
+
+MemoryRetainerNode* MemoryTracker::PushNode(
+    const char* name, const MemoryRetainer* retainer) {
+  MemoryRetainerNode* n = AddNode(name, retainer);
+  node_stack_.push(n);
+  return n;
+}
+
+void MemoryTracker::PopNode() {
+  node_stack_.pop();
 }
 
 }  // namespace node
diff --git a/src/memory_tracker.h b/src/memory_tracker.h
index 18822651f67873..d0f9e0dcad8f1e 100644
--- a/src/memory_tracker.h
+++ b/src/memory_tracker.h
@@ -3,15 +3,19 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include <unordered_set>
+#include <unordered_map>
 #include <queue>
+#include <stack>
+#include <string>
 #include <limits>
 #include <uv.h>
-#include <aliased_buffer.h>
+#include "aliased_buffer.h"
+#include "v8-profiler.h"
 
 namespace node {
 
 class MemoryTracker;
+class MemoryRetainerNode;
 
 namespace crypto {
 class NodeBIO;
@@ -29,6 +33,8 @@ class MemoryRetainer {
   }
 
   virtual bool IsRootNode() const { return false; }
+
+  virtual std::string MemoryInfoName() const { return std::string(); }
 };
 
 class MemoryTracker {
@@ -67,17 +73,32 @@ class MemoryTracker {
   inline void TrackField(const char* name,
                          const AliasedBuffer<NativeT, V8T>& value);
 
-  inline void Track(const MemoryRetainer* value);
-  inline size_t accumulated_size() const { return accumulated_size_; }
+  inline void Track(const MemoryRetainer* value, const char* name = nullptr);
 
   inline void set_track_only_self(bool value) { track_only_self_ = value; }
+  inline v8::EmbedderGraph* graph() { return graph_; }
+  inline v8::Isolate* isolate() { return isolate_; }
 
-  inline MemoryTracker() {}
+  inline explicit MemoryTracker(v8::Isolate* isolate,
+                                v8::EmbedderGraph* graph)
+    : isolate_(isolate), graph_(graph) {}
 
  private:
+  typedef std::unordered_map<const MemoryRetainer*, MemoryRetainerNode*>
+      NodeMap;
+
+  inline MemoryRetainerNode* CurrentNode() const;
+  inline MemoryRetainerNode* AddNode(const char* name,
+                                     const MemoryRetainer* retainer = nullptr);
+  inline MemoryRetainerNode* PushNode(const char* name,
+                                      const MemoryRetainer* retainer = nullptr);
+  inline void PopNode();
+
   bool track_only_self_ = false;
-  size_t accumulated_size_ = 0;
-  std::unordered_set<const MemoryRetainer*> seen_;
+  v8::Isolate* isolate_;
+  v8::EmbedderGraph* graph_;
+  std::stack<MemoryRetainerNode*> node_stack_;
+  NodeMap seen_;
 };
 
 }  // namespace node
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index 0d0791b710c860..3efa6adb4edb0e 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -758,6 +758,8 @@ void TLSWrap::DestroySSL(const FunctionCallbackInfo<Value>& args) {
 
   // Destroy the SSL structure and friends
   wrap->SSLWrap<TLSWrap>::DestroySSL();
+  wrap->enc_in_ = nullptr;
+  wrap->enc_out_ = nullptr;
 
   if (wrap->stream_ != nullptr)
     wrap->stream_->RemoveStreamListener(wrap);
@@ -868,8 +870,10 @@ void TLSWrap::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackThis(this);
   tracker->TrackField("error", error_);
   tracker->TrackField("pending_cleartext_input", pending_cleartext_input_);
-  tracker->TrackField("enc_in", crypto::NodeBIO::FromBIO(enc_in_));
-  tracker->TrackField("enc_out", crypto::NodeBIO::FromBIO(enc_out_));
+  if (enc_in_ != nullptr)
+    tracker->TrackField("enc_in", crypto::NodeBIO::FromBIO(enc_in_));
+  if (enc_out_ != nullptr)
+    tracker->TrackField("enc_out", crypto::NodeBIO::FromBIO(enc_out_));
 }
 
 
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index b45e379ca3f61c..5f4fd3f7073305 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -143,8 +143,8 @@ class TLSWrap : public AsyncWrap,
   static int SelectSNIContextCallback(SSL* s, int* ad, void* arg);
 
   crypto::SecureContext* sc_;
-  BIO* enc_in_;
-  BIO* enc_out_;
+  BIO* enc_in_ = nullptr;
+  BIO* enc_out_ = nullptr;
   std::vector<uv_buf_t> pending_cleartext_input_;
   size_t write_size_;
   WriteWrap* current_write_ = nullptr;

From a9a718696e418d89fe3120ffac48db1a487eb074 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sun, 1 Jul 2018 01:27:09 +0200
Subject: [PATCH 089/116] src: make heap snapshot & embedder graph accessible
 for tests

Add methods that allow inspection of heap snapshots and a JS
version of our own embedder graph.

These can be used in tests and might also prove useful for
ad-hoc debugging. Usage requires `--expose-internals` and
prints a warning similar to our other modules whose primary
purpose is test support.

PR-URL: https://github.com/nodejs/node/pull/21741
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 lib/internal/test/heap.js |  87 ++++++++++++++
 node.gyp                  |   2 +
 src/heap_utils.cc         | 232 ++++++++++++++++++++++++++++++++++++++
 src/node_internals.h      |   1 +
 4 files changed, 322 insertions(+)
 create mode 100644 lib/internal/test/heap.js
 create mode 100644 src/heap_utils.cc

diff --git a/lib/internal/test/heap.js b/lib/internal/test/heap.js
new file mode 100644
index 00000000000000..a9260f651b9c1a
--- /dev/null
+++ b/lib/internal/test/heap.js
@@ -0,0 +1,87 @@
+'use strict';
+
+process.emitWarning(
+  'These APIs are exposed only for testing and are not ' +
+  'tracked by any versioning system or deprecation process.',
+  'internal/test/heap');
+
+const { internalBinding } = require('internal/bootstrap/loaders');
+const { createHeapDump, buildEmbedderGraph } = internalBinding('heap_utils');
+const assert = require('assert');
+
+// This is not suitable for production code. It creates a full V8 heap dump,
+// parses it as JSON, and then creates complex objects from it, leading
+// to significantly increased memory usage.
+function createJSHeapDump() {
+  const dump = createHeapDump();
+  const meta = dump.snapshot.meta;
+
+  const nodes =
+    readHeapInfo(dump.nodes, meta.node_fields, meta.node_types, dump.strings);
+  const edges =
+    readHeapInfo(dump.edges, meta.edge_fields, meta.edge_types, dump.strings);
+
+  for (const node of nodes) {
+    node.incomingEdges = [];
+    node.outgoingEdges = [];
+  }
+
+  let fromNodeIndex = 0;
+  let edgeIndex = 0;
+  for (const { type, name_or_index, to_node } of edges) {
+    while (edgeIndex === nodes[fromNodeIndex].edge_count) {
+      edgeIndex = 0;
+      fromNodeIndex++;
+    }
+    const toNode = nodes[to_node / meta.node_fields.length];
+    const fromNode = nodes[fromNodeIndex];
+    const edge = {
+      type,
+      toNode,
+      fromNode,
+      name: typeof name_or_index === 'string' ? name_or_index : null
+    };
+    toNode.incomingEdges.push(edge);
+    fromNode.outgoingEdges.push(edge);
+    edgeIndex++;
+  }
+
+  for (const node of nodes)
+    assert.strictEqual(node.edge_count, node.outgoingEdges.length);
+
+  return nodes;
+}
+
+function readHeapInfo(raw, fields, types, strings) {
+  const items = [];
+
+  for (var i = 0; i < raw.length; i += fields.length) {
+    const item = {};
+    for (var j = 0; j < fields.length; j++) {
+      const name = fields[j];
+      let type = types[j];
+      if (Array.isArray(type)) {
+        item[name] = type[raw[i + j]];
+      } else if (name === 'name_or_index') {  // type === 'string_or_number'
+        if (item.type === 'element' || item.type === 'hidden')
+          type = 'number';
+        else
+          type = 'string';
+      }
+
+      if (type === 'string') {
+        item[name] = strings[raw[i + j]];
+      } else if (type === 'number' || type === 'node') {
+        item[name] = raw[i + j];
+      }
+    }
+    items.push(item);
+  }
+
+  return items;
+}
+
+module.exports = {
+  createJSHeapDump,
+  buildEmbedderGraph
+};
diff --git a/node.gyp b/node.gyp
index 89ebb0fb95c945..04784715c34f86 100644
--- a/node.gyp
+++ b/node.gyp
@@ -146,6 +146,7 @@
       'lib/internal/repl/await.js',
       'lib/internal/socket_list.js',
       'lib/internal/test/binding.js',
+      'lib/internal/test/heap.js',
       'lib/internal/test/unicode.js',
       'lib/internal/timers.js',
       'lib/internal/tls.js',
@@ -328,6 +329,7 @@
         'src/exceptions.cc',
         'src/fs_event_wrap.cc',
         'src/handle_wrap.cc',
+        'src/heap_utils.cc',
         'src/js_stream.cc',
         'src/module_wrap.cc',
         'src/node.cc',
diff --git a/src/heap_utils.cc b/src/heap_utils.cc
new file mode 100644
index 00000000000000..2d339c580fa076
--- /dev/null
+++ b/src/heap_utils.cc
@@ -0,0 +1,232 @@
+#include "node_internals.h"
+#include "env.h"
+
+using v8::Array;
+using v8::Boolean;
+using v8::Context;
+using v8::EmbedderGraph;
+using v8::EscapableHandleScope;
+using v8::FunctionCallbackInfo;
+using v8::HandleScope;
+using v8::HeapSnapshot;
+using v8::Isolate;
+using v8::JSON;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Number;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+namespace node {
+namespace heap {
+
+class JSGraphJSNode : public EmbedderGraph::Node {
+ public:
+  const char* Name() override { return "<JS Node>"; }
+  size_t SizeInBytes() override { return 0; }
+  bool IsEmbedderNode() override { return false; }
+  Local<Value> JSValue() { return StrongPersistentToLocal(persistent_); }
+
+  int IdentityHash() {
+    Local<Value> v = JSValue();
+    if (v->IsObject()) return v.As<Object>()->GetIdentityHash();
+    if (v->IsName()) return v.As<v8::Name>()->GetIdentityHash();
+    if (v->IsInt32()) return v.As<v8::Int32>()->Value();
+    return 0;
+  }
+
+  JSGraphJSNode(Isolate* isolate, Local<Value> val)
+      : persistent_(isolate, val) {
+    CHECK(!val.IsEmpty());
+  }
+
+  struct Hash {
+    inline size_t operator()(JSGraphJSNode* n) const {
+      return n->IdentityHash();
+    }
+  };
+
+  struct Equal {
+    inline bool operator()(JSGraphJSNode* a, JSGraphJSNode* b) const {
+      return a->JSValue()->SameValue(b->JSValue());
+    }
+  };
+
+ private:
+  Persistent<Value> persistent_;
+};
+
+class JSGraph : public EmbedderGraph {
+ public:
+  explicit JSGraph(Isolate* isolate) : isolate_(isolate) {}
+
+  Node* V8Node(const Local<Value>& value) override {
+    std::unique_ptr<JSGraphJSNode> n { new JSGraphJSNode(isolate_, value) };
+    auto it = engine_nodes_.find(n.get());
+    if (it != engine_nodes_.end())
+      return *it;
+    engine_nodes_.insert(n.get());
+    return AddNode(std::unique_ptr<Node>(n.release()));
+  }
+
+  Node* AddNode(std::unique_ptr<Node> node) override {
+    Node* n = node.get();
+    nodes_.emplace(std::move(node));
+    return n;
+  }
+
+  void AddEdge(Node* from, Node* to) override {
+    edges_[from].insert(to);
+  }
+
+  MaybeLocal<Array> CreateObject() const {
+    EscapableHandleScope handle_scope(isolate_);
+    Local<Context> context = isolate_->GetCurrentContext();
+
+    std::unordered_map<Node*, Local<Object>> info_objects;
+    Local<Array> nodes = Array::New(isolate_, nodes_.size());
+    Local<String> edges_string = FIXED_ONE_BYTE_STRING(isolate_, "edges");
+    Local<String> is_root_string = FIXED_ONE_BYTE_STRING(isolate_, "isRoot");
+    Local<String> name_string = FIXED_ONE_BYTE_STRING(isolate_, "name");
+    Local<String> size_string = FIXED_ONE_BYTE_STRING(isolate_, "size");
+    Local<String> value_string = FIXED_ONE_BYTE_STRING(isolate_, "value");
+    Local<String> wraps_string = FIXED_ONE_BYTE_STRING(isolate_, "wraps");
+
+    for (const std::unique_ptr<Node>& n : nodes_)
+      info_objects[n.get()] = Object::New(isolate_);
+
+    {
+      HandleScope handle_scope(isolate_);
+      size_t i = 0;
+      for (const std::unique_ptr<Node>& n : nodes_) {
+        Local<Object> obj = info_objects[n.get()];
+        Local<Value> value;
+        if (!String::NewFromUtf8(isolate_, n->Name(),
+                                 v8::NewStringType::kNormal).ToLocal(&value) ||
+            obj->Set(context, name_string, value).IsNothing() ||
+            obj->Set(context, is_root_string,
+                     Boolean::New(isolate_, n->IsRootNode())).IsNothing() ||
+            obj->Set(context, size_string,
+                     Number::New(isolate_, n->SizeInBytes())).IsNothing() ||
+            obj->Set(context, edges_string,
+                     Array::New(isolate_)).IsNothing()) {
+          return MaybeLocal<Array>();
+        }
+        if (nodes->Set(context, i++, obj).IsNothing())
+          return MaybeLocal<Array>();
+        if (!n->IsEmbedderNode()) {
+          value = static_cast<JSGraphJSNode*>(n.get())->JSValue();
+          if (obj->Set(context, value_string, value).IsNothing())
+            return MaybeLocal<Array>();
+        }
+      }
+    }
+
+    for (const std::unique_ptr<Node>& n : nodes_) {
+      Node* wraps = n->WrapperNode();
+      if (wraps == nullptr) continue;
+      Local<Object> from = info_objects[n.get()];
+      Local<Object> to = info_objects[wraps];
+      if (from->Set(context, wraps_string, to).IsNothing())
+        return MaybeLocal<Array>();
+    }
+
+    for (const auto& edge_info : edges_) {
+      Node* source = edge_info.first;
+      Local<Value> edges;
+      if (!info_objects[source]->Get(context, edges_string).ToLocal(&edges) ||
+          !edges->IsArray()) {
+        return MaybeLocal<Array>();
+      }
+
+      size_t i = 0;
+      for (Node* target : edge_info.second) {
+        if (edges.As<Array>()->Set(context,
+                                   i++,
+                                   info_objects[target]).IsNothing()) {
+          return MaybeLocal<Array>();
+        }
+      }
+    }
+
+    return handle_scope.Escape(nodes);
+  }
+
+ private:
+  Isolate* isolate_;
+  std::unordered_set<std::unique_ptr<Node>> nodes_;
+  std::unordered_set<JSGraphJSNode*, JSGraphJSNode::Hash, JSGraphJSNode::Equal>
+      engine_nodes_;
+  std::unordered_map<Node*, std::unordered_set<Node*>> edges_;
+};
+
+void BuildEmbedderGraph(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  JSGraph graph(env->isolate());
+  Environment::BuildEmbedderGraph(env->isolate(), &graph, env);
+  Local<Array> ret;
+  if (graph.CreateObject().ToLocal(&ret))
+    args.GetReturnValue().Set(ret);
+}
+
+
+class BufferOutputStream : public v8::OutputStream {
+ public:
+  BufferOutputStream() : buffer_(new JSString()) {}
+
+  void EndOfStream() override {}
+  int GetChunkSize() override { return 1024 * 1024; }
+  WriteResult WriteAsciiChunk(char* data, int size) override {
+    buffer_->Append(data, size);
+    return kContinue;
+  }
+
+  Local<String> ToString(Isolate* isolate) {
+    return String::NewExternalOneByte(isolate,
+                                      buffer_.release()).ToLocalChecked();
+  }
+
+ private:
+  class JSString : public String::ExternalOneByteStringResource {
+   public:
+    void Append(char* data, size_t count) {
+      store_.append(data, count);
+    }
+
+    const char* data() const override { return store_.data(); }
+    size_t length() const override { return store_.size(); }
+
+   private:
+    std::string store_;
+  };
+
+  std::unique_ptr<JSString> buffer_;
+};
+
+void CreateHeapDump(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  const HeapSnapshot* snapshot = isolate->GetHeapProfiler()->TakeHeapSnapshot();
+  BufferOutputStream out;
+  snapshot->Serialize(&out, HeapSnapshot::kJSON);
+  const_cast<HeapSnapshot*>(snapshot)->Delete();
+  Local<Value> ret;
+  if (JSON::Parse(isolate->GetCurrentContext(),
+                  out.ToString(isolate)).ToLocal(&ret)) {
+    args.GetReturnValue().Set(ret);
+  }
+}
+
+void Initialize(Local<Object> target,
+                Local<Value> unused,
+                Local<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+
+  env->SetMethodNoSideEffect(target, "buildEmbedderGraph", BuildEmbedderGraph);
+  env->SetMethodNoSideEffect(target, "createHeapDump", CreateHeapDump);
+}
+
+}  // namespace heap
+}  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(heap_utils, node::heap::Initialize)
diff --git a/src/node_internals.h b/src/node_internals.h
index cd791f8c059caf..d29400d4594569 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -111,6 +111,7 @@ struct sockaddr;
     V(domain)                                                                 \
     V(fs)                                                                     \
     V(fs_event_wrap)                                                          \
+    V(heap_utils)                                                             \
     V(http2)                                                                  \
     V(http_parser)                                                            \
     V(inspector)                                                              \

From 7352b72fc9a740c21dc848a3bb7b0f67313f5776 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Tue, 10 Jul 2018 22:12:23 +0200
Subject: [PATCH 090/116] test: add heap snapshot tests

Add a number of tests that validate that heap snapshots
contain what we expect them to contain, and cross-check
against a JS version of our own embedder graphs.

PR-URL: https://github.com/nodejs/node/pull/21741
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 test/common/README.md                     | 37 +++++++++++
 test/common/heap.js                       | 80 +++++++++++++++++++++++
 test/parallel/test-heapdump-dns.js        | 17 +++++
 test/parallel/test-heapdump-fs-promise.js | 16 +++++
 test/parallel/test-heapdump-http2.js      | 76 +++++++++++++++++++++
 test/parallel/test-heapdump-inspector.js  | 21 ++++++
 test/parallel/test-heapdump-tls.js        | 33 ++++++++++
 test/parallel/test-heapdump-worker.js     | 27 ++++++++
 test/parallel/test-heapdump-zlib.js       | 17 +++++
 9 files changed, 324 insertions(+)
 create mode 100644 test/common/heap.js
 create mode 100644 test/parallel/test-heapdump-dns.js
 create mode 100644 test/parallel/test-heapdump-fs-promise.js
 create mode 100644 test/parallel/test-heapdump-http2.js
 create mode 100644 test/parallel/test-heapdump-inspector.js
 create mode 100644 test/parallel/test-heapdump-tls.js
 create mode 100644 test/parallel/test-heapdump-worker.js
 create mode 100644 test/parallel/test-heapdump-zlib.js

diff --git a/test/common/README.md b/test/common/README.md
index 111ce45b00360c..c0051ad9f7ca6e 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -10,6 +10,7 @@ This directory contains modules used to test the Node.js implementation.
 * [DNS module](#dns-module)
 * [Duplex pair helper](#duplex-pair-helper)
 * [Fixtures module](#fixtures-module)
+* [Heap dump checker module](#heap-dump-checker-module)
 * [HTTP2 module](#http2-module)
 * [Internet module](#internet-module)
 * [tmpdir module](#tmpdir-module)
@@ -538,6 +539,42 @@ Returns the result of
 Returns the result of
 `fs.readFileSync(path.join(fixtures.fixturesDir, 'keys', arg), 'enc')`.
 
+## Heap dump checker module
+
+This provides utilities for checking the validity of heap dumps.
+This requires the usage of `--expose-internals`.
+
+### heap.recordState()
+
+Create a heap dump and an embedder graph copy for inspection.
+The returned object has a `validateSnapshotNodes` function similar to the
+one listed below. (`heap.validateSnapshotNodes(...)` is a shortcut for
+`heap.recordState().validateSnapshotNodes(...)`.)
+
+### heap.validateSnapshotNodes(name, expected, options)
+
+* `name` [&lt;string>] Look for this string as the name of heap dump nodes.
+* `expected` [&lt;Array>] A list of objects, possibly with an `children`
+  property that points to expected other adjacent nodes.
+* `options` [&lt;Array>]
+  * `loose` [&lt;boolean>] Do not expect an exact listing of occurrences
+    of nodes with name `name` in `expected`.
+
+Create a heap dump and an embedder graph copy and validate occurrences.
+
+<!-- eslint-disable no-undef, no-unused-vars, node-core/required-modules, strict -->
+```js
+validateSnapshotNodes('TLSWRAP', [
+  {
+    children: [
+      { name: 'enc_out' },
+      { name: 'enc_in' },
+      { name: 'TLSWrap' }
+    ]
+  }
+]);
+```
+
 ## HTTP/2 Module
 
 The http2.js module provides a handful of utilities for creating mock HTTP/2
diff --git a/test/common/heap.js b/test/common/heap.js
new file mode 100644
index 00000000000000..a02de9a60651f4
--- /dev/null
+++ b/test/common/heap.js
@@ -0,0 +1,80 @@
+/* eslint-disable node-core/required-modules */
+'use strict';
+const assert = require('assert');
+const util = require('util');
+
+let internalTestHeap;
+try {
+  internalTestHeap = require('internal/test/heap');
+} catch (e) {
+  console.log('using `test/common/heap.js` requires `--expose-internals`');
+  throw e;
+}
+const { createJSHeapDump, buildEmbedderGraph } = internalTestHeap;
+
+class State {
+  constructor() {
+    this.snapshot = createJSHeapDump();
+    this.embedderGraph = buildEmbedderGraph();
+  }
+
+  validateSnapshotNodes(name, expected, { loose = false } = {}) {
+    const snapshot = this.snapshot.filter(
+      (node) => node.name === 'Node / ' + name && node.type !== 'string');
+    if (loose)
+      assert(snapshot.length >= expected.length);
+    else
+      assert.strictEqual(snapshot.length, expected.length);
+    for (const expectedNode of expected) {
+      if (expectedNode.children) {
+        for (const expectedChild of expectedNode.children) {
+          const check = typeof expectedChild === 'function' ?
+            expectedChild :
+            (node) => [expectedChild.name, 'Node / ' + expectedChild.name]
+              .includes(node.name);
+
+          assert(snapshot.some((node) => {
+            return node.outgoingEdges.map((edge) => edge.toNode).some(check);
+          }), `expected to find child ${util.inspect(expectedChild)} ` +
+              `in ${util.inspect(snapshot)}`);
+        }
+      }
+    }
+
+    const graph = this.embedderGraph.filter((node) => node.name === name);
+    if (loose)
+      assert(graph.length >= expected.length);
+    else
+      assert.strictEqual(graph.length, expected.length);
+    for (const expectedNode of expected) {
+      if (expectedNode.edges) {
+        for (const expectedChild of expectedNode.children) {
+          const check = typeof expectedChild === 'function' ?
+            expectedChild : (node) => {
+              return node.name === expectedChild.name ||
+                (node.value &&
+                 node.value.constructor &&
+                 node.value.constructor.name === expectedChild.name);
+            };
+
+          assert(graph.some((node) => node.edges.some(check)),
+                 `expected to find child ${util.inspect(expectedChild)} ` +
+                 `in ${util.inspect(snapshot)}`);
+        }
+      }
+    }
+  }
+}
+
+function recordState() {
+  return new State();
+}
+
+function validateSnapshotNodes(...args) {
+  return recordState().validateSnapshotNodes(...args);
+}
+
+module.exports = {
+  recordState,
+  validateSnapshotNodes
+};
diff --git a/test/parallel/test-heapdump-dns.js b/test/parallel/test-heapdump-dns.js
new file mode 100644
index 00000000000000..011503f5874d5a
--- /dev/null
+++ b/test/parallel/test-heapdump-dns.js
@@ -0,0 +1,17 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+const { validateSnapshotNodes } = require('../common/heap');
+
+validateSnapshotNodes('DNSCHANNEL', []);
+const dns = require('dns');
+validateSnapshotNodes('DNSCHANNEL', [{}]);
+dns.resolve('localhost', () => {});
+validateSnapshotNodes('DNSCHANNEL', [
+  {
+    children: [
+      { name: 'task list' },
+      { name: 'ChannelWrap' }
+    ]
+  }
+]);
diff --git a/test/parallel/test-heapdump-fs-promise.js b/test/parallel/test-heapdump-fs-promise.js
new file mode 100644
index 00000000000000..be44b3d8731bc1
--- /dev/null
+++ b/test/parallel/test-heapdump-fs-promise.js
@@ -0,0 +1,16 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+const { validateSnapshotNodes } = require('../common/heap');
+const fs = require('fs').promises;
+
+validateSnapshotNodes('FSREQPROMISE', []);
+fs.stat(__filename);
+validateSnapshotNodes('FSREQPROMISE', [
+  {
+    children: [
+      { name: 'FSReqPromise' },
+      { name: 'Float64Array' }  // Stat array
+    ]
+  }
+]);
diff --git a/test/parallel/test-heapdump-http2.js b/test/parallel/test-heapdump-http2.js
new file mode 100644
index 00000000000000..19a70d8c44b15d
--- /dev/null
+++ b/test/parallel/test-heapdump-http2.js
@@ -0,0 +1,76 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const { recordState } = require('../common/heap');
+const http2 = require('http2');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+{
+  const state = recordState();
+  state.validateSnapshotNodes('HTTP2SESSION', []);
+  state.validateSnapshotNodes('HTTP2STREAM', []);
+}
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+  stream.respondWithFile(__filename);
+});
+server.listen(0, () => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('response', common.mustCall(() => {
+    const state = recordState();
+    state.validateSnapshotNodes('HTTP2STREAM', [
+      {
+        children: [
+          { name: 'Http2Stream' }
+        ]
+      },
+    ], { loose: true });
+    state.validateSnapshotNodes('FILEHANDLE', [
+      {
+        children: [
+          { name: 'FileHandle' }
+        ]
+      }
+    ]);
+    state.validateSnapshotNodes('TCPWRAP', [
+      {
+        children: [
+          { name: 'TCP' }
+        ]
+      }
+    ], { loose: true });
+    state.validateSnapshotNodes('TCPSERVERWRAP', [
+      {
+        children: [
+          { name: 'TCP' }
+        ]
+      }
+    ], { loose: true });
+    state.validateSnapshotNodes('STREAMPIPE', [
+      {
+        children: [
+          { name: 'StreamPipe' }
+        ]
+      }
+    ]);
+    state.validateSnapshotNodes('HTTP2SESSION', [
+      {
+        children: [
+          { name: 'Http2Session' },
+          { name: 'streams' }
+        ]
+      }
+    ], { loose: true });
+  }));
+
+  req.resume();
+  req.on('end', common.mustCall(() => {
+    client.close();
+    server.close();
+  }));
+  req.end();
+});
diff --git a/test/parallel/test-heapdump-inspector.js b/test/parallel/test-heapdump-inspector.js
new file mode 100644
index 00000000000000..355b8d0d0a1d51
--- /dev/null
+++ b/test/parallel/test-heapdump-inspector.js
@@ -0,0 +1,21 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const { validateSnapshotNodes } = require('../common/heap');
+const inspector = require('inspector');
+
+const session = new inspector.Session();
+validateSnapshotNodes('INSPECTORJSBINDING', []);
+session.connect();
+validateSnapshotNodes('INSPECTORJSBINDING', [
+  {
+    children: [
+      { name: 'session' },
+      { name: 'Connection' },
+      (node) => node.type === 'closure' || typeof node.value === 'function'
+    ]
+  }
+]);
diff --git a/test/parallel/test-heapdump-tls.js b/test/parallel/test-heapdump-tls.js
new file mode 100644
index 00000000000000..be14b7b5f7ca64
--- /dev/null
+++ b/test/parallel/test-heapdump-tls.js
@@ -0,0 +1,33 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const { validateSnapshotNodes } = require('../common/heap');
+const net = require('net');
+const tls = require('tls');
+
+validateSnapshotNodes('TLSWRAP', []);
+
+const server = net.createServer(common.mustCall((c) => {
+  c.end();
+})).listen(0, common.mustCall(() => {
+  const c = tls.connect({ port: server.address().port });
+
+  c.on('error', common.mustCall(() => {
+    server.close();
+  }));
+  c.write('hello');
+
+  validateSnapshotNodes('TLSWRAP', [
+    {
+      children: [
+        { name: 'enc_out' },
+        { name: 'enc_in' },
+        { name: 'TLSWrap' }
+      ]
+    }
+  ]);
+}));
diff --git a/test/parallel/test-heapdump-worker.js b/test/parallel/test-heapdump-worker.js
new file mode 100644
index 00000000000000..68d2ccd1abbc29
--- /dev/null
+++ b/test/parallel/test-heapdump-worker.js
@@ -0,0 +1,27 @@
+// Flags: --expose-internals --experimental-worker
+'use strict';
+require('../common');
+const { validateSnapshotNodes } = require('../common/heap');
+const { Worker } = require('worker_threads');
+
+validateSnapshotNodes('WORKER', []);
+const worker = new Worker('setInterval(() => {}, 100);', { eval: true });
+validateSnapshotNodes('WORKER', [
+  {
+    children: [
+      { name: 'thread_exit_async' },
+      { name: 'env' },
+      { name: 'MESSAGEPORT' },
+      { name: 'Worker' }
+    ]
+  }
+]);
+validateSnapshotNodes('MESSAGEPORT', [
+  {
+    children: [
+      { name: 'data' },
+      { name: 'MessagePort' }
+    ]
+  }
+], { loose: true });
+worker.terminate();
diff --git a/test/parallel/test-heapdump-zlib.js b/test/parallel/test-heapdump-zlib.js
new file mode 100644
index 00000000000000..7a749902f5aaf6
--- /dev/null
+++ b/test/parallel/test-heapdump-zlib.js
@@ -0,0 +1,17 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+const { validateSnapshotNodes } = require('../common/heap');
+const zlib = require('zlib');
+
+validateSnapshotNodes('ZLIB', []);
+// eslint-disable-next-line no-unused-vars
+const gunzip = zlib.createGunzip();
+validateSnapshotNodes('ZLIB', [
+  {
+    children: [
+      { name: 'Zlib' },
+      { name: 'zlib memory' }
+    ]
+  }
+]);

From 10f9374ea302b84f831d28a23bfe83d666594bbd Mon Sep 17 00:00:00 2001
From: Sam Ruby <rubys@intertwingly.net>
Date: Thu, 12 Jul 2018 13:28:42 -0400
Subject: [PATCH 091/116] doc: make markdown input compliant
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21780
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/crypto.md | 12 ++++----
 doc/api/fs.md     |  4 +--
 doc/api/http.md   |  6 ++--
 doc/api/os.md     | 15 ++++-----
 doc/api/stream.md | 77 ++++-------------------------------------------
 5 files changed, 25 insertions(+), 89 deletions(-)

diff --git a/doc/api/crypto.md b/doc/api/crypto.md
index 376a8c8a223d93..87f26716af3230 100644
--- a/doc/api/crypto.md
+++ b/doc/api/crypto.md
@@ -2674,18 +2674,18 @@ the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
   </tr>
   <tr>
     <td><code>RSA_PSS_SALTLEN_DIGEST</code></td>
-    <td>Sets the salt length for `RSA_PKCS1_PSS_PADDING` to the digest size
-        when signing or verifying.</td>
+    <td>Sets the salt length for <code>RSA_PKCS1_PSS_PADDING</code> to the
+        digest size when signing or verifying.</td>
   </tr>
   <tr>
     <td><code>RSA_PSS_SALTLEN_MAX_SIGN</code></td>
-    <td>Sets the salt length for `RSA_PKCS1_PSS_PADDING` to the maximum
-        permissible value when signing data.</td>
+    <td>Sets the salt length for <code>RSA_PKCS1_PSS_PADDING</code> to the
+        maximum permissible value when signing data.</td>
   </tr>
   <tr>
     <td><code>RSA_PSS_SALTLEN_AUTO</code></td>
-    <td>Causes the salt length for `RSA_PKCS1_PSS_PADDING` to be determined
-        automatically when verifying a signature.</td>
+    <td>Causes the salt length for <code>RSA_PKCS1_PSS_PADDING</code> to be
+        determined automatically when verifying a signature.</td>
   </tr>
   <tr>
     <td><code>POINT_CONVERSION_COMPRESSED</code></td>
diff --git a/doc/api/fs.md b/doc/api/fs.md
index d3f981cf79964d..dafda61124ec00 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -4373,8 +4373,8 @@ The following constants are meant for use with `fs.open()`.
   <tr>
   <td><code>O_NOATIME</code></td>
     <td>Flag indicating reading accesses to the file system will no longer
-    result in an update to the `atime` information associated with the file.
-    This flag is available on Linux operating systems only.</td>
+    result in an update to the <code>atime</code> information associated with
+    the file.  This flag is available on Linux operating systems only.</td>
   </tr>
   <tr>
     <td><code>O_NOFOLLOW</code></td>
diff --git a/doc/api/http.md b/doc/api/http.md
index 578f21c45e30ca..fd8bb02776d03f 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1896,9 +1896,9 @@ changes:
     Authorization header.
   * `agent` {http.Agent | boolean} Controls [`Agent`][] behavior. Possible
     values:
-   * `undefined` (default): use [`http.globalAgent`][] for this host and port.
-   * `Agent` object: explicitly use the passed in `Agent`.
-   * `false`: causes a new `Agent` with default values to be used.
+    * `undefined` (default): use [`http.globalAgent`][] for this host and port.
+    * `Agent` object: explicitly use the passed in `Agent`.
+    * `false`: causes a new `Agent` with default values to be used.
   * `createConnection` {Function} A function that produces a socket/stream to
     use for the request when the `agent` option is not used. This can be used to
     avoid creating a custom `Agent` class just to override the default
diff --git a/doc/api/os.md b/doc/api/os.md
index 8db4904d29a489..b7bd246f97dbfd 100644
--- a/doc/api/os.md
+++ b/doc/api/os.md
@@ -442,7 +442,7 @@ The following signal constants are exported by `os.constants.signals`:
   <tr>
     <td><code>SIGINT</code></td>
     <td>Sent to indicate when a user wishes to interrupt a process
-    (`(Ctrl+C)`).</td>
+    (<code>(Ctrl+C)</code>).</td>
   </tr>
   <tr>
     <td><code>SIGQUIT</code></td>
@@ -855,9 +855,9 @@ The following error constants are exported by `os.constants.errno`:
   </tr>
   <tr>
     <td><code>EOPNOTSUPP</code></td>
-    <td>Indicates that an operation is not supported on the socket.
-    Note that while `ENOTSUP` and `EOPNOTSUPP` have the same value on Linux,
-    according to POSIX.1 these error values should be distinct.)</td>
+    <td>Indicates that an operation is not supported on the socket.  Note that
+    while <code>ENOTSUP</code> and <code>EOPNOTSUPP</code> have the same value
+    on Linux, according to POSIX.1 these error values should be distinct.)</td>
   </tr>
   <tr>
     <td><code>EOVERFLOW</code></td>
@@ -1114,7 +1114,8 @@ The following error codes are specific to the Windows operating system:
   </tr>
   <tr>
     <td><code>WSAVERNOTSUPPORTED</code></td>
-    <td>Indicates that the `winsock.dll` version is out of range.</td>
+    <td>Indicates that the <code>winsock.dll</code> version is out of
+    range.</td>
   </tr>
   <tr>
     <td><code>WSANOTINITIALISED</code></td>
@@ -1197,8 +1198,8 @@ information.
   </tr>
   <tr>
     <td><code>RTLD_LOCAL</code></td>
-    <td>The converse of `RTLD_GLOBAL`. This is the default behavior if neither
-    flag is specified.</td>
+    <td>The converse of <code>RTLD_GLOBAL</code>. This is the default behavior
+    if neither flag is specified.</td>
   </tr>
   <tr>
     <td><code>RTLD_DEEPBIND</code></td>
diff --git a/doc/api/stream.md b/doc/api/stream.md
index 7e7a3fb92a933d..5ca713a27b6e0f 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -1419,77 +1419,12 @@ class MyWritable extends Writable {
 The new stream class must then implement one or more specific methods, depending
 on the type of stream being created, as detailed in the chart below:
 
-<table>
-  <thead>
-    <tr>
-      <th>
-        <p>Use-case</p>
-      </th>
-      <th>
-        <p>Class</p>
-      </th>
-      <th>
-        <p>Method(s) to implement</p>
-      </th>
-    </tr>
-  </thead>
-  <tr>
-    <td>
-      <p>Reading only</p>
-    </td>
-    <td>
-      <p>[`Readable`](#stream_class_stream_readable)</p>
-    </td>
-    <td>
-      <p><code>[_read][stream-_read]</code></p>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <p>Writing only</p>
-    </td>
-    <td>
-      <p>[`Writable`](#stream_class_stream_writable)</p>
-    </td>
-    <td>
-      <p>
-        <code>[_write][stream-_write]</code>,
-        <code>[_writev][stream-_writev]</code>,
-        <code>[_final][stream-_final]</code>
-      </p>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <p>Reading and writing</p>
-    </td>
-    <td>
-      <p>[`Duplex`](#stream_class_stream_duplex)</p>
-    </td>
-    <td>
-      <p>
-        <code>[_read][stream-_read]</code>,
-        <code>[_write][stream-_write]</code>,
-        <code>[_writev][stream-_writev]</code>,
-        <code>[_final][stream-_final]</code></p>
-    </td>
-  </tr>
-  <tr>
-    <td>
-      <p>Operate on written data, then read the result</p>
-    </td>
-    <td>
-      <p>[`Transform`](#stream_class_stream_transform)</p>
-    </td>
-    <td>
-      <p>
-        <code>[_transform][stream-_transform]</code>,
-        <code>[_flush][stream-_flush]</code>,
-        <code>[_final][stream-_final]</code>
-      </p>
-    </td>
-  </tr>
-</table>
+| Use-case | Class | Method(s) to implement |
+| -------- | ----- | ---------------------- |
+| Reading only | [`Readable`] | <code>[_read][stream-_read]</code> |
+| Writing only | [`Writable`] | <code>[_write][stream-_write]</code>, <code>[_writev][stream-_writev]</code>, <code>[_final][stream-_final]</code> |
+| Reading and writing | [`Duplex`] | <code>[_read][stream-_read]</code>, <code>[_write][stream-_write]</code>, <code>[_writev][stream-_writev]</code>, <code>[_final][stream-_final]</code> |
+| Operate on written data, then read the result | [`Transform`] | <code>[_transform][stream-_transform]</code>, <code>[_flush][stream-_flush]</code>, <code>[_final][stream-_final]</code> |
 
 The implementation code for a stream should *never* call the "public" methods
 of a stream that are intended for use by consumers (as described in the

From 51dfebf9acc30173f15b099cd0c378aaa892fd00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Sun, 15 Jul 2018 17:27:07 +0200
Subject: [PATCH 092/116] doc: fix vm.runInNewContext signature

The `options` parameter cannot be passed without `sandbox`.

PR-URL: https://github.com/nodejs/node/pull/21824
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/vm.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/vm.md b/doc/api/vm.md
index d3be08f89b377a..7d14293ac4e45b 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -758,7 +758,7 @@ console.log(util.inspect(sandbox));
 // { globalVar: 1024 }
 ```
 
-## vm.runInNewContext(code[, sandbox][, options])
+## vm.runInNewContext(code[, sandbox[, options]])
 <!-- YAML
 added: v0.3.1
 -->

From 1019c2d317d39fd76fe92a33d82b5ccea608602e Mon Sep 17 00:00:00 2001
From: Javier Gonzalez <xaviergonz@gmail.com>
Date: Sun, 4 Mar 2018 19:28:38 +0100
Subject: [PATCH 093/116] src: fix async hooks crashing when there is no node
 context

PR-URL: https://github.com/nodejs/node/pull/19134
Fixes: https://github.com/nodejs/node/issues/19104
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
---
 src/env-inl.h           |  3 +++
 src/env.cc              | 20 +++++++++++++++++++-
 src/env.h               |  2 ++
 src/node_context_data.h | 10 ++++++++++
 4 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/env-inl.h b/src/env-inl.h
index 4ef9665cbddfed..5c359c04d907cb 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -290,6 +290,9 @@ inline void Environment::AssignToContext(v8::Local<v8::Context> context,
                                          const ContextInfo& info) {
   context->SetAlignedPointerInEmbedderData(
       ContextEmbedderIndex::kEnvironment, this);
+  // Used by EnvPromiseHook to know that we are on a node context.
+  context->SetAlignedPointerInEmbedderData(
+    ContextEmbedderIndex::kContextTag, Environment::kNodeContextTagPtr);
 #if HAVE_INSPECTOR
   inspector_agent()->ContextCreated(context, info);
 #endif  // HAVE_INSPECTOR
diff --git a/src/env.cc b/src/env.cc
index 3d1a9372c93c7d..fffe5d61d0685a 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -4,6 +4,7 @@
 #include "node_buffer.h"
 #include "node_platform.h"
 #include "node_file.h"
+#include "node_context_data.h"
 #include "node_worker.h"
 #include "tracing/agent.h"
 
@@ -28,6 +29,10 @@ using v8::Symbol;
 using v8::Value;
 using worker::Worker;
 
+int const Environment::kNodeContextTag = 0x6e6f64;
+void* Environment::kNodeContextTagPtr = const_cast<void*>(
+    static_cast<const void*>(&Environment::kNodeContextTag));
+
 IsolateData::IsolateData(Isolate* isolate,
                          uv_loop_t* event_loop,
                          MultiIsolatePlatform* platform,
@@ -430,7 +435,20 @@ bool Environment::RemovePromiseHook(promise_hook_func fn, void* arg) {
 void Environment::EnvPromiseHook(v8::PromiseHookType type,
                                  v8::Local<v8::Promise> promise,
                                  v8::Local<v8::Value> parent) {
-  Environment* env = Environment::GetCurrent(promise->CreationContext());
+  Local<v8::Context> context = promise->CreationContext();
+
+  // Grow the embedder data if necessary to make sure we are not out of bounds
+  // when reading the magic number.
+  context->SetAlignedPointerInEmbedderData(
+      ContextEmbedderIndex::kContextTagBoundary, nullptr);
+  int* magicNumberPtr = reinterpret_cast<int*>(
+      context->GetAlignedPointerFromEmbedderData(
+          ContextEmbedderIndex::kContextTag));
+  if (magicNumberPtr != Environment::kNodeContextTagPtr) {
+    return;
+  }
+
+  Environment* env = Environment::GetCurrent(context);
   for (const PromiseHookCallback& hook : env->promise_hooks_) {
     hook.cb_(type, promise, parent, hook.arg_);
   }
diff --git a/src/env.h b/src/env.h
index 9c7f4d1ba8ae3f..ede221400b4965 100644
--- a/src/env.h
+++ b/src/env.h
@@ -902,6 +902,8 @@ class Environment {
   uint64_t thread_id_ = 0;
   std::unordered_set<worker::Worker*> sub_worker_contexts_;
 
+  static void* kNodeContextTagPtr;
+  static int const kNodeContextTag;
 
 #if HAVE_INSPECTOR
   std::unique_ptr<inspector::Agent> inspector_agent_;
diff --git a/src/node_context_data.h b/src/node_context_data.h
index 522ce292d21684..3892b31354027d 100644
--- a/src/node_context_data.h
+++ b/src/node_context_data.h
@@ -19,10 +19,20 @@ namespace node {
 #define NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX 34
 #endif
 
+#ifndef NODE_CONTEXT_TAG
+#define NODE_CONTEXT_TAG 35
+#endif
+
+#ifndef NODE_CONTEXT_TAG_BOUNDARY
+#define NODE_CONTEXT_TAG_BOUNDARY 36
+#endif
+
 enum ContextEmbedderIndex {
   kEnvironment = NODE_CONTEXT_EMBEDDER_DATA_INDEX,
   kSandboxObject = NODE_CONTEXT_SANDBOX_OBJECT_INDEX,
   kAllowWasmCodeGeneration = NODE_CONTEXT_ALLOW_WASM_CODE_GENERATION_INDEX,
+  kContextTag = NODE_CONTEXT_TAG,
+  kContextTagBoundary = NODE_CONTEXT_TAG_BOUNDARY,
 };
 
 }  // namespace node

From 238ef58841fef61cda438589705c2af9d2fb4b91 Mon Sep 17 00:00:00 2001
From: RidgeA <antongriadchenko@gmail.com>
Date: Wed, 11 Jul 2018 17:29:42 +0300
Subject: [PATCH 094/116] http2: remove `waitTrailers` listener after closing a
 stream

When `writeHeader` of `Http2ServerResponse` instance are called with
204, 205 and 304 status codes an underlying stream closes.
If call `end` method after sending any of these status codes it will
cause an error `TypeError: Cannot read property 'Symbol(trailers)' of
undefined` because a reference to `Http2ServerResponse` instance
associated with Http2Stream already was deleted.
The closing of stream causes emitting `waitTrailers` event and, when
this event handles inside `onStreamTrailerReady` handler, there is
no reference to Http2ServerResponse instance.

Fixes: https://github.com/nodejs/node/issues/21740
PR-URL: https://github.com/nodejs/node/pull/21764
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
---
 lib/internal/http2/compat.js                  |  2 +
 ...esponse-end-after-statuses-without-body.js | 47 +++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js

diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 88879484ebaab7..4a006107b2fcea 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -391,6 +391,8 @@ function onStreamCloseResponse() {
   state.closed = true;
 
   this[kProxySocket] = null;
+
+  this.removeListener('wantTrailers', onStreamTrailersReady);
   this[kResponse] = undefined;
 
   res.emit('finish');
diff --git a/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js b/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
new file mode 100644
index 00000000000000..83d5521bf2473f
--- /dev/null
+++ b/test/parallel/test-http2-compat-serverresponse-end-after-statuses-without-body.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const h2 = require('http2');
+
+// This test case ensures that calling of res.end after sending
+// 204, 205 and 304 HTTP statuses will not cause an error
+// See issue: https://github.com/nodejs/node/issues/21740
+
+const {
+  HTTP_STATUS_NO_CONTENT,
+  HTTP_STATUS_RESET_CONTENT,
+  HTTP_STATUS_NOT_MODIFIED
+} = h2.constants;
+
+const statusWithouBody = [
+  HTTP_STATUS_NO_CONTENT,
+  HTTP_STATUS_RESET_CONTENT,
+  HTTP_STATUS_NOT_MODIFIED,
+];
+const STATUS_CODES_COUNT = statusWithouBody.length;
+
+const server = h2.createServer(common.mustCall(function(req, res) {
+  res.writeHead(statusWithouBody.pop());
+  res.end();
+}, STATUS_CODES_COUNT));
+
+server.listen(0, common.mustCall(function() {
+  const url = `http://localhost:${server.address().port}`;
+  const client = h2.connect(url, common.mustCall(() => {
+    let responseCount = 0;
+    const closeAfterResponse = () => {
+      if (STATUS_CODES_COUNT === ++responseCount) {
+        client.destroy();
+        server.close();
+      }
+    };
+
+    for (let i = 0; i < STATUS_CODES_COUNT; i++) {
+      const request = client.request();
+      request.on('response', common.mustCall(closeAfterResponse));
+    }
+
+  }));
+}));

From 32ad163038100a4a5c20ddf5c3b5cf2aea93a8eb Mon Sep 17 00:00:00 2001
From: Ryuichi Sakagami <shagamiiiii@gmail.com>
Date: Sun, 8 Jul 2018 19:09:18 +0900
Subject: [PATCH 095/116] test: add test of fs.promises write for non-string
 buffers

PR-URL: https://github.com/nodejs/node/pull/21708
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 .../test-fs-promises-file-handle-write.js        | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-fs-promises-file-handle-write.js b/test/parallel/test-fs-promises-file-handle-write.js
index d7812745c5439e..3cff69f48dfb72 100644
--- a/test/parallel/test-fs-promises-file-handle-write.js
+++ b/test/parallel/test-fs-promises-file-handle-write.js
@@ -45,8 +45,22 @@ async function validateNonUint8ArrayWrite() {
   assert.deepStrictEqual(Buffer.from(buffer, 'utf8'), readFileData);
 }
 
+async function validateNonStringValuesWrite() {
+  const filePathForHandle = path.resolve(tmpDir, 'tmp-non-string-write.txt');
+  const fileHandle = await open(filePathForHandle, 'w+');
+  const nonStringValues = [123, {}, new Map()];
+  for (const nonStringValue of nonStringValues) {
+    await fileHandle.write(nonStringValue);
+  }
+
+  const readFileData = fs.readFileSync(filePathForHandle);
+  const expected = ['123', '[object Object]', '[object Map]'].join('');
+  assert.deepStrictEqual(Buffer.from(expected, 'utf8'), readFileData);
+}
+
 Promise.all([
   validateWrite(),
   validateEmptyWrite(),
-  validateNonUint8ArrayWrite()
+  validateNonUint8ArrayWrite(),
+  validateNonStringValuesWrite()
 ]).then(common.mustCall());

From a2edb5987060ed101b08db18fe6b9cd930dae254 Mon Sep 17 00:00:00 2001
From: Ryuichi Sakagami <shagamiiiii@gmail.com>
Date: Sun, 8 Jul 2018 19:10:12 +0900
Subject: [PATCH 096/116] test: fix comment of fs.promises write

PR-URL: https://github.com/nodejs/node/pull/21708
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/parallel/test-fs-promises-file-handle-write.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-fs-promises-file-handle-write.js b/test/parallel/test-fs-promises-file-handle-write.js
index 3cff69f48dfb72..49df2bf54f45ed 100644
--- a/test/parallel/test-fs-promises-file-handle-write.js
+++ b/test/parallel/test-fs-promises-file-handle-write.js
@@ -3,7 +3,7 @@
 const common = require('../common');
 
 // The following tests validate base functionality for the fs.promises
-// FileHandle.read method.
+// FileHandle.write method.
 
 const fs = require('fs');
 const { open } = fs.promises;

From 4e60ce8f87fef6307bc2ca947b69da5c08ccdacd Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sun, 15 Jul 2018 10:52:36 -0700
Subject: [PATCH 097/116] test: fix flaky test-debug-prompt

Be sure to send `.exit` only once to avoid spurious EPIPE and possibly
other errors.

Fixes: https://github.com/nodejs/node/issues/21724

PR-URL: https://github.com/nodejs/node/pull/21826
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
---
 test/sequential/test-debug-prompt.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/sequential/test-debug-prompt.js b/test/sequential/test-debug-prompt.js
index 902bce34fc46f4..e32f4646900536 100644
--- a/test/sequential/test-debug-prompt.js
+++ b/test/sequential/test-debug-prompt.js
@@ -7,9 +7,12 @@ const spawn = require('child_process').spawn;
 const proc = spawn(process.execPath, ['inspect', 'foo']);
 proc.stdout.setEncoding('utf8');
 
+let needToSendExit = true;
 let output = '';
 proc.stdout.on('data', (data) => {
   output += data;
-  if (output.includes('debug> '))
+  if (output.includes('debug> ') && needToSendExit) {
     proc.stdin.write('.exit\n');
+    needToSendExit = false;
+  }
 });

From 73cafd853cc338a34c8dcfe043feb37ec9d32b98 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 19 May 2018 00:55:54 +0200
Subject: [PATCH 098/116] console,util: avoid pair array generation in C++

Use a plain `[key, value, key, value]`-style list instead
of an array of pairs for inspecting collections.

This also fixes a bug with `console.table()` where
inspecting a non-key-value `MapIterator` would have
led to odd results.

PR-URL: https://github.com/nodejs/node/pull/20831
Refs: https://github.com/nodejs/node/pull/20719#discussion_r189342513
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 lib/console.js                      | 28 +++++++++++++++++++---------
 lib/util.js                         | 28 ++++++++++++++++++++--------
 src/node_util.cc                    | 25 ++++++-------------------
 test/parallel/test-console-table.js | 20 ++++++++++++++++++++
 test/parallel/test-util-inspect.js  |  4 ++--
 5 files changed, 67 insertions(+), 38 deletions(-)

diff --git a/lib/console.js b/lib/console.js
index fee3f8ac0b155d..7d6f9c97299e64 100644
--- a/lib/console.js
+++ b/lib/console.js
@@ -356,17 +356,27 @@ Console.prototype.table = function(tabularData, properties) {
   const getIndexArray = (length) => ArrayFrom({ length }, (_, i) => inspect(i));
 
   const mapIter = isMapIterator(tabularData);
+  let isKeyValue = false;
+  let i = 0;
   if (mapIter)
-    tabularData = previewEntries(tabularData);
+    [ tabularData, isKeyValue ] = previewEntries(tabularData);
 
-  if (mapIter || isMap(tabularData)) {
+  if (isKeyValue || isMap(tabularData)) {
     const keys = [];
     const values = [];
     let length = 0;
-    for (const [k, v] of tabularData) {
-      keys.push(inspect(k));
-      values.push(inspect(v));
-      length++;
+    if (mapIter) {
+      for (; i < tabularData.length / 2; ++i) {
+        keys.push(inspect(tabularData[i * 2]));
+        values.push(inspect(tabularData[i * 2 + 1]));
+        length++;
+      }
+    } else {
+      for (const [k, v] of tabularData) {
+        keys.push(inspect(k));
+        values.push(inspect(v));
+        length++;
+      }
     }
     return final([
       iterKey, keyKey, valuesKey
@@ -379,9 +389,9 @@ Console.prototype.table = function(tabularData, properties) {
 
   const setIter = isSetIterator(tabularData);
   if (setIter)
-    tabularData = previewEntries(tabularData);
+    [ tabularData ] = previewEntries(tabularData);
 
-  const setlike = setIter || isSet(tabularData);
+  const setlike = setIter || (mapIter && !isKeyValue) || isSet(tabularData);
   if (setlike) {
     const values = [];
     let length = 0;
@@ -400,7 +410,7 @@ Console.prototype.table = function(tabularData, properties) {
   const valuesKeyArray = [];
   const indexKeyArray = ObjectKeys(tabularData);
 
-  for (var i = 0; i < indexKeyArray.length; i++) {
+  for (; i < indexKeyArray.length; i++) {
     const item = tabularData[indexKeyArray[i]];
     const primitive = item === null ||
         (typeof item !== 'function' && typeof item !== 'object');
diff --git a/lib/util.js b/lib/util.js
index 15611fdae108df..8160d802b0332f 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -984,7 +984,7 @@ function formatMap(ctx, value, recurseTimes, keys) {
 
 function formatWeakSet(ctx, value, recurseTimes, keys) {
   const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
-  const entries = previewEntries(value).slice(0, maxArrayLength + 1);
+  const [ entries ] = previewEntries(value).slice(0, maxArrayLength + 1);
   const maxLength = Math.min(maxArrayLength, entries.length);
   let output = new Array(maxLength);
   for (var i = 0; i < maxLength; ++i)
@@ -1001,14 +1001,16 @@ function formatWeakSet(ctx, value, recurseTimes, keys) {
 
 function formatWeakMap(ctx, value, recurseTimes, keys) {
   const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
-  const entries = previewEntries(value).slice(0, maxArrayLength + 1);
-  const remainder = entries.length > maxArrayLength;
-  const len = entries.length - (remainder ? 1 : 0);
+  const [ entries ] = previewEntries(value).slice(0, (maxArrayLength + 1) * 2);
+  // Entries exist as [key1, val1, key2, val2, ...]
+  const remainder = entries.length / 2 > maxArrayLength;
+  const len = entries.length / 2 - (remainder ? 1 : 0);
   const maxLength = Math.min(maxArrayLength, len);
   let output = new Array(maxLength);
-  for (var i = 0; i < len; i++) {
-    output[i] = `${formatValue(ctx, entries[i][0], recurseTimes)} => ` +
-      formatValue(ctx, entries[i][1], recurseTimes);
+  for (var i = 0; i < maxLength; i++) {
+    const pos = i * 2;
+    output[i] = `${formatValue(ctx, entries[pos], recurseTimes)} => ` +
+      formatValue(ctx, entries[pos + 1], recurseTimes);
   }
   // Sort all entries to have a halfway reliable output (if more entries than
   // retrieved ones exist, we can not reliably return the same output).
@@ -1020,9 +1022,19 @@ function formatWeakMap(ctx, value, recurseTimes, keys) {
   return output;
 }
 
+function zip2(list) {
+  const ret = Array(list.length / 2);
+  for (var i = 0; i < ret.length; ++i)
+    ret[i] = [list[2 * i], list[2 * i + 1]];
+  return ret;
+}
+
 function formatCollectionIterator(ctx, value, recurseTimes, keys) {
   const output = [];
-  for (const entry of previewEntries(value)) {
+  var [ entries, isKeyValue ] = previewEntries(value);
+  if (isKeyValue)
+    entries = zip2(entries);
+  for (const entry of entries) {
     if (ctx.maxArrayLength === output.length) {
       output.push('... more items');
       break;
diff --git a/src/node_util.cc b/src/node_util.cc
index 724bb3603cfddd..ef7dc8a818bf11 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -53,29 +53,16 @@ static void PreviewEntries(const FunctionCallbackInfo<Value>& args) {
   if (!args[0]->IsObject())
     return;
 
+  Environment* env = Environment::GetCurrent(args);
   bool is_key_value;
   Local<Array> entries;
   if (!args[0].As<Object>()->PreviewEntries(&is_key_value).ToLocal(&entries))
     return;
-  if (!is_key_value)
-    return args.GetReturnValue().Set(entries);
-
-  uint32_t length = entries->Length();
-  CHECK_EQ(length % 2, 0);
-
-  Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
-
-  Local<Array> pairs = Array::New(env->isolate(), length / 2);
-  for (uint32_t i = 0; i < length / 2; i++) {
-    Local<Array> pair = Array::New(env->isolate(), 2);
-    pair->Set(context, 0, entries->Get(context, i * 2).ToLocalChecked())
-        .FromJust();
-    pair->Set(context, 1, entries->Get(context, i * 2 + 1).ToLocalChecked())
-        .FromJust();
-    pairs->Set(context, i, pair).FromJust();
-  }
-  args.GetReturnValue().Set(pairs);
+  Local<Array> ret = Array::New(env->isolate(), 2);
+  ret->Set(env->context(), 0, entries).FromJust();
+  ret->Set(env->context(), 1, v8::Boolean::New(env->isolate(), is_key_value))
+      .FromJust();
+  return args.GetReturnValue().Set(ret);
 }
 
 // Side effect-free stringification that will never throw exceptions.
diff --git a/test/parallel/test-console-table.js b/test/parallel/test-console-table.js
index 9ff4641d65923c..844d2e01e4180b 100644
--- a/test/parallel/test-console-table.js
+++ b/test/parallel/test-console-table.js
@@ -120,6 +120,26 @@ test(new Map([[1, 1], [2, 2], [3, 3]]).entries(), `
 └───────────────────┴─────┴────────┘
 `);
 
+test(new Map([[1, 1], [2, 2], [3, 3]]).values(), `
+┌───────────────────┬────────┐
+│ (iteration index) │ Values │
+├───────────────────┼────────┤
+│         0         │   1    │
+│         1         │   2    │
+│         2         │   3    │
+└───────────────────┴────────┘
+`);
+
+test(new Map([[1, 1], [2, 2], [3, 3]]).keys(), `
+┌───────────────────┬────────┐
+│ (iteration index) │ Values │
+├───────────────────┼────────┤
+│         0         │   1    │
+│         1         │   2    │
+│         2         │   3    │
+└───────────────────┴────────┘
+`);
+
 test(new Set([1, 2, 3]).values(), `
 ┌───────────────────┬────────┐
 │ (iteration index) │ Values │
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index 874797665dc415..826e965fd0044d 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -447,13 +447,13 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
 {
   const map = new Map();
   map.set(1, 2);
-  const vals = previewEntries(map.entries());
+  const [ vals ] = previewEntries(map.entries());
   const valsOutput = [];
   for (const o of vals) {
     valsOutput.push(o);
   }
 
-  assert.strictEqual(util.inspect(valsOutput), '[ [ 1, 2 ] ]');
+  assert.strictEqual(util.inspect(valsOutput), '[ 1, 2 ]');
 }
 
 // Test for other constructors in different context.

From 2a0862cec9698cea86c8908379cb880d58f6b871 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Thu, 12 Jul 2018 16:56:15 +0200
Subject: [PATCH 099/116] console: fix timeEnd() not coercing the input
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The input of console.timeEnd() was not coerced to a string. That way
labels were not found and the entry was not removed anymore.

PR-URL: https://github.com/nodejs/node/pull/21779
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 lib/console.js                | 6 ++++--
 test/parallel/test-console.js | 6 +++++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/lib/console.js b/lib/console.js
index 7d6f9c97299e64..98ab0c35712d97 100644
--- a/lib/console.js
+++ b/lib/console.js
@@ -231,6 +231,8 @@ Console.prototype.time = function time(label = 'default') {
 };
 
 Console.prototype.timeEnd = function timeEnd(label = 'default') {
+  // Coerces everything other than Symbol to a string
+  label = `${label}`;
   const hasWarned = timeLogImpl(this, 'timeEnd', label);
   if (!hasWarned) {
     this._times.delete(label);
@@ -238,13 +240,13 @@ Console.prototype.timeEnd = function timeEnd(label = 'default') {
 };
 
 Console.prototype.timeLog = function timeLog(label, ...data) {
+  // Coerces everything other than Symbol to a string
+  label = `${label}`;
   timeLogImpl(this, 'timeLog', label, data);
 };
 
 // Returns true if label was not found
 function timeLogImpl(self, name, label = 'default', data) {
-  // Coerces everything other than Symbol to a string
-  label = `${label}`;
   const time = self._times.get(label);
   if (!time) {
     process.emitWarning(`No such label '${label}' for console.${name}()`);
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index b8dfac2f29888a..a0e6e322a5e42a 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -132,11 +132,14 @@ console.timeEnd('constructor');
 console.time('hasOwnProperty');
 console.timeEnd('hasOwnProperty');
 
-// verify that values are coerced to strings
+// Verify that values are coerced to strings.
 console.time([]);
 console.timeEnd([]);
 console.time({});
 console.timeEnd({});
+// Repeat the object call to verify that everything really worked.
+console.time({});
+console.timeEnd({});
 console.time(null);
 console.timeEnd(null);
 console.time(undefined);
@@ -212,6 +215,7 @@ assert.ok(/^hasOwnProperty: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 // verify that console.time() coerces label values to strings as expected
 assert.ok(/^: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^\[object Object\]: \d+\.\d{3}ms$/.test(strings.shift().trim()));
+assert.ok(/^\[object Object\]: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^null: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));
 assert.ok(/^default: \d+\.\d{3}ms$/.test(strings.shift().trim()));

From 8c97ffb2f5664108a066b63f777565419b9dd983 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 2 Jul 2018 20:29:57 +0200
Subject: [PATCH 100/116] assert: improve simple assert

1) If simple assert is called in the very first line of a file and
it causes an error, it used to report the wrong code. The reason
is that the column that is reported is faulty. This is fixed by
subtracting the offset from now on in such cases.

2) The actual code read is now limited to the part that is actually
required to visualize the call site. All other code in e.g. minified
files will not cause a significant overhead anymore.

3) The number of allocations is now significantly lower than it used
to be. The buffer is reused until the correct line in the code is
found. In general the algorithm tries to safe operations where
possible.

4) The indentation is now corrected depending on where the statement
actually beginns.

5) It is now possible to handle `.call()` and `.apply()` properly.

6) The user defined function name will now always be used instead of
only choosing either `assert.ok()` or `assert()`.

PR-URL: https://github.com/nodejs/node/pull/21626
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Ben Coe <bencoe@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/assert.js                           | 224 +++++++++++++++---------
 test/fixtures/assert-first-line.js      |   2 +
 test/fixtures/assert-long-line.js       |   1 +
 test/parallel/test-assert-first-line.js |  23 +++
 test/parallel/test-assert.js            |  63 +++++--
 5 files changed, 221 insertions(+), 92 deletions(-)
 create mode 100644 test/fixtures/assert-first-line.js
 create mode 100644 test/fixtures/assert-long-line.js
 create mode 100644 test/parallel/test-assert-first-line.js

diff --git a/lib/assert.js b/lib/assert.js
index 47c0e3c1402bdd..5a25e73a9dc1bc 100644
--- a/lib/assert.js
+++ b/lib/assert.js
@@ -34,6 +34,10 @@ const { NativeModule } = require('internal/bootstrap/loaders');
 
 let isDeepEqual;
 let isDeepStrictEqual;
+let parseExpressionAt;
+let findNodeAround;
+let columnOffset = 0;
+let decoder;
 
 function lazyLoadComparison() {
   const comparison = require('internal/util/comparisons');
@@ -113,52 +117,141 @@ function fail(actual, expected, message, operator, stackStartFn) {
 assert.fail = fail;
 
 // The AssertionError is defined in internal/error.
-// new assert.AssertionError({ message: message,
-//                             actual: actual,
-//                             expected: expected });
 assert.AssertionError = AssertionError;
 
-function getBuffer(fd, assertLine) {
+function findColumn(fd, column, code) {
+  if (code.length > column + 100) {
+    try {
+      return parseCode(code, column);
+    } catch {
+      // End recursion in case no code could be parsed. The expression should
+      // have been found after 2500 characters, so stop trying.
+      if (code.length - column > 2500) {
+        // eslint-disable-next-line no-throw-literal
+        throw null;
+      }
+    }
+  }
+  // Read up to 2500 bytes more than necessary in columns. That way we address
+  // multi byte characters and read enough data to parse the code.
+  const bytesToRead = column - code.length + 2500;
+  const buffer = Buffer.allocUnsafe(bytesToRead);
+  const bytesRead = readSync(fd, buffer, 0, bytesToRead);
+  code += decoder.write(buffer.slice(0, bytesRead));
+  // EOF: fast path.
+  if (bytesRead < bytesToRead) {
+    return parseCode(code, column);
+  }
+  // Read potentially missing code.
+  return findColumn(fd, column, code);
+}
+
+function getCode(fd, line, column) {
+  let bytesRead = 0;
+  if (line === 0) {
+    // Special handle line number one. This is more efficient and simplifies the
+    // rest of the algorithm. Read more than the regular column number in bytes
+    // to prevent multiple reads in case multi byte characters are used.
+    return findColumn(fd, column, '');
+  }
   let lines = 0;
   // Prevent blocking the event loop by limiting the maximum amount of
   // data that may be read.
   let maxReads = 64; // bytesPerRead * maxReads = 512 kb
-  let bytesRead = 0;
-  let startBuffer = 0; // Start reading from that char on
   const bytesPerRead = 8192;
-  const buffers = [];
-  do {
-    const buffer = Buffer.allocUnsafe(bytesPerRead);
+  // Use a single buffer up front that is reused until the call site is found.
+  let buffer = Buffer.allocUnsafe(bytesPerRead);
+  while (maxReads-- !== 0) {
+    // Only allocate a new buffer in case the needed line is found. All data
+    // before that can be discarded.
+    buffer = lines < line ? buffer : Buffer.allocUnsafe(bytesPerRead);
     bytesRead = readSync(fd, buffer, 0, bytesPerRead);
+    // Read the buffer until the required code line is found.
     for (var i = 0; i < bytesRead; i++) {
-      if (buffer[i] === 10) {
-        lines++;
-        if (lines === assertLine) {
-          startBuffer = i + 1;
-        // Read up to 15 more lines to make sure all code gets matched
-        } else if (lines === assertLine + 16) {
-          buffers.push(buffer.slice(startBuffer, i));
-          return buffers;
+      if (buffer[i] === 10 && ++lines === line) {
+        // If the end of file is reached, directly parse the code and return.
+        if (bytesRead < bytesPerRead) {
+          return parseCode(buffer.toString('utf8', i + 1, bytesRead), column);
         }
+        // Check if the read code is sufficient or read more until the whole
+        // expression is read. Make sure multi byte characters are preserved
+        // properly by using the decoder.
+        const code = decoder.write(buffer.slice(i + 1, bytesRead));
+        return findColumn(fd, column, code);
       }
     }
-    if (lines >= assertLine) {
-      buffers.push(buffer.slice(startBuffer, bytesRead));
-      // Reset the startBuffer in case we need more than one chunk
-      startBuffer = 0;
+  }
+}
+
+function parseCode(code, offset) {
+  // Lazy load acorn.
+  if (parseExpressionAt === undefined) {
+    ({ parseExpressionAt } = require('internal/deps/acorn/dist/acorn'));
+    ({ findNodeAround } = require('internal/deps/acorn/dist/walk'));
+  }
+  let node;
+  let start = 0;
+  // Parse the read code until the correct expression is found.
+  do {
+    try {
+      node = parseExpressionAt(code, start);
+      start = node.end + 1 || start;
+      // Find the CallExpression in the tree.
+      node = findNodeAround(node, offset, 'CallExpression');
+    } catch (err) {
+      // Unexpected token error and the like.
+      start += err.raisedAt || 1;
+      if (start > offset) {
+        // No matching expression found. This could happen if the assert
+        // expression is bigger than the provided buffer.
+        // eslint-disable-next-line no-throw-literal
+        throw null;
+      }
     }
-  } while (--maxReads !== 0 && bytesRead !== 0);
-  return buffers;
+  } while (node === undefined || node.node.end < offset);
+
+  return [
+    node.node.start,
+    code.slice(node.node.start, node.node.end)
+        .replace(escapeSequencesRegExp, escapeFn)
+  ];
 }
 
-function getErrMessage(call) {
+function getErrMessage(message, fn) {
+  const tmpLimit = Error.stackTraceLimit;
+  // Make sure the limit is set to 1. Otherwise it could fail (<= 0) or it
+  // does to much work.
+  Error.stackTraceLimit = 1;
+  // We only need the stack trace. To minimize the overhead use an object
+  // instead of an error.
+  const err = {};
+  Error.captureStackTrace(err, fn);
+  Error.stackTraceLimit = tmpLimit;
+
+  const tmpPrepare = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, stack) => stack;
+  const call = err.stack[0];
+  Error.prepareStackTrace = tmpPrepare;
+
   const filename = call.getFileName();
+
   if (!filename) {
-    return;
+    return message;
   }
 
   const line = call.getLineNumber() - 1;
-  const column = call.getColumnNumber() - 1;
+  let column = call.getColumnNumber() - 1;
+
+  // Line number one reports the wrong column due to being wrapped in a
+  // function. Remove that offset to get the actual call.
+  if (line === 0) {
+    if (columnOffset === 0) {
+      const { wrapper } = require('internal/modules/cjs/loader');
+      columnOffset = wrapper[0].length;
+    }
+    column -= columnOffset;
+  }
+
   const identifier = `${filename}${line}${column}`;
 
   if (errorCache.has(identifier)) {
@@ -171,57 +264,49 @@ function getErrMessage(call) {
     return;
   }
 
-  let fd, message;
+  let fd;
   try {
+    // Set the stack trace limit to zero. This makes sure unexpected token
+    // errors are handled faster.
+    Error.stackTraceLimit = 0;
+
+    if (decoder === undefined) {
+      const { StringDecoder } = require('string_decoder');
+      decoder = new StringDecoder('utf8');
+    }
+
     fd = openSync(filename, 'r', 0o666);
-    const buffers = getBuffer(fd, line);
-    const code = Buffer.concat(buffers).toString('utf8');
-    // Lazy load acorn.
-    const { parseExpressionAt } = require('internal/deps/acorn/dist/acorn');
-    const nodes = parseExpressionAt(code, column);
-    // Node type should be "CallExpression" and some times
-    // "SequenceExpression".
-    const node = nodes.type === 'CallExpression' ? nodes : nodes.expressions[0];
-    const name = node.callee.name;
-    // Calling `ok` with .apply or .call is uncommon but we use a simple
-    // safeguard nevertheless.
-    if (name !== 'apply' && name !== 'call') {
-    // Only use `assert` and `assert.ok` to reference the "real API" and
-    // not user defined function names.
-      const ok = name === 'ok' ? '.ok' : '';
-      const args = node.arguments;
-      message = code
-        .slice(args[0].start, args[args.length - 1].end)
-        .replace(escapeSequencesRegExp, escapeFn);
+    // Reset column and message.
+    [column, message] = getCode(fd, line, column);
+    // Flush unfinished multi byte characters.
+    decoder.end();
+    // Always normalize indentation, otherwise the message could look weird.
+    if (message.indexOf('\n') !== -1) {
       if (EOL === '\r\n') {
         message = message.replace(/\r\n/g, '\n');
       }
-      // Always normalize indentation, otherwise the message could look weird.
-      if (message.indexOf('\n') !== -1) {
-        const tmp = message.split('\n');
-        message = tmp[0];
-        for (var i = 1; i < tmp.length; i++) {
-          let pos = 0;
-          while (pos < column &&
-              (tmp[i][pos] === ' ' || tmp[i][pos] === '\t')) {
-            pos++;
-          }
-          message += `\n  ${tmp[i].slice(pos)}`;
+      const frames = message.split('\n');
+      message = frames.shift();
+      for (const frame of frames) {
+        let pos = 0;
+        while (pos < column && (frame[pos] === ' ' || frame[pos] === '\t')) {
+          pos++;
         }
+        message += `\n  ${frame.slice(pos)}`;
       }
-      message = 'The expression evaluated to a falsy value:' +
-        `\n\n  assert${ok}(${message})\n`;
     }
+    message = `The expression evaluated to a falsy value:\n\n  ${message}\n`;
     // Make sure to always set the cache! No matter if the message is
     // undefined or not
     errorCache.set(identifier, message);
 
     return message;
-
   } catch (e) {
   // Invalidate cache to prevent trying to read this part again.
     errorCache.set(identifier, undefined);
   } finally {
+    // Reset limit.
+    Error.stackTraceLimit = tmpLimit;
     if (fd !== undefined)
       closeSync(fd);
   }
@@ -235,25 +320,8 @@ function innerOk(fn, argLen, value, message) {
       generatedMessage = true;
       message = 'No value argument passed to `assert.ok()`';
     } else if (message == null) {
-      // Use the call as error message if possible.
-      // This does not work with e.g. the repl.
-      // eslint-disable-next-line no-restricted-syntax
-      const err = new Error();
-      // Make sure the limit is set to 1. Otherwise it could fail (<= 0) or it
-      // does to much work.
-      const tmpLimit = Error.stackTraceLimit;
-      Error.stackTraceLimit = 1;
-      Error.captureStackTrace(err, fn);
-      Error.stackTraceLimit = tmpLimit;
-
-      const tmpPrepare = Error.prepareStackTrace;
-      Error.prepareStackTrace = (_, stack) => stack;
-      const call = err.stack[0];
-      Error.prepareStackTrace = tmpPrepare;
-
-      // Make sure it would be "null" in case that is used.
-      message = getErrMessage(call) || message;
       generatedMessage = true;
+      message = getErrMessage(message, fn);
     } else if (message instanceof Error) {
       throw message;
     }
diff --git a/test/fixtures/assert-first-line.js b/test/fixtures/assert-first-line.js
new file mode 100644
index 00000000000000..8a65113559c981
--- /dev/null
+++ b/test/fixtures/assert-first-line.js
@@ -0,0 +1,2 @@
+'use strict'; const ässört = require('assert'); ässört(true); ässört.ok(''); ässört(null);
+// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(false);
diff --git a/test/fixtures/assert-long-line.js b/test/fixtures/assert-long-line.js
new file mode 100644
index 00000000000000..cab3507ac8d779
--- /dev/null
+++ b/test/fixtures/assert-long-line.js
@@ -0,0 +1 @@
+'use strict'; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */ const assert = require('assert'); assert(true); assert.ok(''); assert(null);
diff --git a/test/parallel/test-assert-first-line.js b/test/parallel/test-assert-first-line.js
new file mode 100644
index 00000000000000..32eadbf74156c3
--- /dev/null
+++ b/test/parallel/test-assert-first-line.js
@@ -0,0 +1,23 @@
+'use strict';
+
+// Verify that asserting in the very first line produces the expected result.
+
+require('../common');
+const assert = require('assert');
+const { path } = require('../common/fixtures');
+
+assert.throws(
+  () => require(path('assert-first-line')),
+  {
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: "The expression evaluated to a falsy value:\n\n  ässört.ok('')\n"
+  }
+);
+
+assert.throws(
+  () => require(path('assert-long-line')),
+  {
+    name: 'AssertionError [ERR_ASSERTION]',
+    message: "The expression evaluated to a falsy value:\n\n  assert.ok('')\n"
+  }
+);
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 4b4b802701b778..ec7fe58d05c6c4 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -457,7 +457,7 @@ assert.throws(
       code: 'ERR_ASSERTION',
       type: assert.AssertionError,
       message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert.ok(typeof 123 === 'string')\n"
+               "assert.ok(\n    typeof 123 === 'string'\n  )\n"
     }
   );
   Error.stackTraceLimit = tmpLimit;
@@ -661,7 +661,7 @@ common.expectsError(
       code: 'ERR_ASSERTION',
       type: assert.AssertionError,
       message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert(Buffer.from('test') instanceof Error)\n"
+               "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
     }
   );
   common.expectsError(
@@ -670,7 +670,7 @@ common.expectsError(
       code: 'ERR_ASSERTION',
       type: assert.AssertionError,
       message: 'The expression evaluated to a falsy value:\n\n  ' +
-               "assert(Buffer.from('test') instanceof Error)\n"
+               "assert(\n    (Buffer.from('test') instanceof Error)\n  )\n"
     }
   );
   fs.close = tmp;
@@ -690,11 +690,13 @@ common.expectsError(
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
     message: 'The expression evaluated to a falsy value:\n\n' +
-             '  assert((() => \'string\')()\n' +
+             '  a(\n' +
+             '    (() => \'string\')()\n' +
              '    // eslint-disable-next-line\n' +
              '    ===\n' +
              '    123 instanceof\n' +
-             '        Buffer)\n'
+             '        Buffer\n' +
+             '  )\n'
   }
 );
 
@@ -712,11 +714,13 @@ common.expectsError(
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
     message: 'The expression evaluated to a falsy value:\n\n' +
-             '  assert((() => \'string\')()\n' +
+             '  a(\n' +
+             '    (() => \'string\')()\n' +
              '    // eslint-disable-next-line\n' +
              '    ===\n' +
              '  123 instanceof\n' +
-             '        Buffer)\n'
+             '        Buffer\n' +
+             '  )\n'
   }
 );
 
@@ -731,16 +735,19 @@ Buffer
   code: 'ERR_ASSERTION',
   type: assert.AssertionError,
   message: 'The expression evaluated to a falsy value:\n\n' +
-           '  assert((\n' +
+           '  a((\n' +
            '    () => \'string\')() ===\n' +
            '  123 instanceof\n' +
-           '  Buffer)\n'
+           '  Buffer\n' +
+           '  )\n'
   }
 );
 /* eslint-enable indent */
 
 common.expectsError(
-  () => assert(null, undefined),
+  () => {
+    assert(true); assert(null, undefined);
+  },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
@@ -750,11 +757,38 @@ common.expectsError(
 );
 
 common.expectsError(
-  () => assert.ok.apply(null, [0]),
+  () => {
+    assert
+     .ok(null, undefined);
+  },
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: '0 == true'
+    message: 'The expression evaluated to a falsy value:\n\n  ' +
+             'ok(null, undefined)\n'
+  }
+);
+
+common.expectsError(
+  // eslint-disable-next-line dot-notation, quotes
+  () => assert['ok']["apply"](null, [0]),
+  {
+    code: 'ERR_ASSERTION',
+    type: assert.AssertionError,
+    message: 'The expression evaluated to a falsy value:\n\n  ' +
+             'assert[\'ok\']["apply"](null, [0])\n'
+  }
+);
+
+common.expectsError(
+  () => {
+    const wrapper = (fn, value) => fn(value);
+    wrapper(assert, false);
+  },
+  {
+    code: 'ERR_ASSERTION',
+    type: assert.AssertionError,
+    message: 'The expression evaluated to a falsy value:\n\n  fn(value)\n'
   }
 );
 
@@ -763,7 +797,8 @@ common.expectsError(
   {
     code: 'ERR_ASSERTION',
     type: assert.AssertionError,
-    message: '0 == true',
+    message: 'The expression evaluated to a falsy value:\n\n  ' +
+             'assert.ok.call(null, 0)\n',
     generatedMessage: true
   }
 );
@@ -778,7 +813,7 @@ common.expectsError(
   }
 );
 
-// works in eval
+// Works in eval.
 common.expectsError(
   () => new Function('assert', 'assert(1 === 2);')(assert),
   {

From 53b587a5afa3811e1e8c3b052a04380858dd3f30 Mon Sep 17 00:00:00 2001
From: Andreas Madsen <amwebdk@gmail.com>
Date: Mon, 9 Jul 2018 15:31:18 +0200
Subject: [PATCH 101/116] doc: add documentation for buffer.byteOffset

Also document a common issue when casting a Buffer object to a
TypedArray object.

Fixes: https://github.com/nodejs/node/issues/19301

PR-URL: https://github.com/nodejs/node/pull/21718
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 doc/api/buffer.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index c219f00e4a1f48..8e1d1c325b6ca7 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -992,6 +992,31 @@ console.log(buffer.buffer === arrayBuffer);
 // Prints: true
 ```
 
+### buf.byteOffset
+
+* {integer} The `byteOffset` on the underlying `ArrayBuffer` object based on
+  which this `Buffer` object is created.
+
+When setting `byteOffset` in `Buffer.from(ArrayBuffer, byteOffset, length)`
+or sometimes when allocating a buffer smaller than `Buffer.poolSize` the
+buffer doesn't start from a zero offset on the underlying `ArrayBuffer`.
+
+This can cause problems when accessing the underlying `ArrayBuffer` directly
+using `buf.buffer`, as the first bytes in this `ArrayBuffer` may be unrelated
+to the `buf` object itself.
+
+A common issue is when casting a `Buffer` object to a `TypedArray` object,
+in this case one needs to specify the `byteOffset` correctly:
+
+```js
+// Create a buffer smaller than `Buffer.poolSize`.
+const nodeBuffer = new Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+// When casting the Node.js Buffer to an Int8 TypedArray remember to use the
+// byteOffset.
+new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);
+```
+
 ### buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
 <!-- YAML
 added: v0.11.13

From 6bb2b5a51d5686be252ead277eaa76fa16ce0fb5 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 20:05:24 +0200
Subject: [PATCH 102/116] build: account for pure C sources in
 `build-addons-napi`

PR-URL: https://github.com/nodejs/node/pull/21797
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Makefile b/Makefile
index 03285c9d42cee3..168dd27ea03d6d 100644
--- a/Makefile
+++ b/Makefile
@@ -370,6 +370,7 @@ ADDONS_NAPI_BINDING_GYPS := \
 		$(wildcard test/addons-napi/*/binding.gyp))
 
 ADDONS_NAPI_BINDING_SOURCES := \
+	$(filter-out test/addons-napi/??_*/*.c, $(wildcard test/addons-napi/*/*.c)) \
 	$(filter-out test/addons-napi/??_*/*.cc, $(wildcard test/addons-napi/*/*.cc)) \
 	$(filter-out test/addons-napi/??_*/*.h, $(wildcard test/addons-napi/*/*.h))
 

From 0b3c80ca31db5bbf79e0439304653e14e6302e30 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Wed, 27 Jun 2018 12:55:33 +0200
Subject: [PATCH 103/116] http2: fix issues with aborted `respondWithFile()`s

PR-URL: https://github.com/nodejs/node/pull/21561
Fixes: https://github.com/nodejs/node/issues/20824
Fixes: https://github.com/nodejs/node/issues/21560
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 src/node_http2.cc                             |  3 +-
 src/stream_pipe.cc                            | 11 ++++--
 src/stream_pipe.h                             | 10 +++--
 ...ttp2-respond-with-file-connection-abort.js | 37 +++++++++++++++++++
 4 files changed, 52 insertions(+), 9 deletions(-)
 create mode 100644 test/parallel/test-http2-respond-with-file-connection-abort.js

diff --git a/src/node_http2.cc b/src/node_http2.cc
index dfe0e4e7ae3e9a..d1319c9d82fd97 100644
--- a/src/node_http2.cc
+++ b/src/node_http2.cc
@@ -2060,10 +2060,9 @@ int Http2Stream::DoWrite(WriteWrap* req_wrap,
                          uv_buf_t* bufs,
                          size_t nbufs,
                          uv_stream_t* send_handle) {
-  CHECK(!this->IsDestroyed());
   CHECK_NULL(send_handle);
   Http2Scope h2scope(this);
-  if (!IsWritable()) {
+  if (!IsWritable() || IsDestroyed()) {
     req_wrap->Done(UV_EOF);
     return 0;
   }
diff --git a/src/stream_pipe.cc b/src/stream_pipe.cc
index bfe7d4297257a0..e19f98e35d2821 100644
--- a/src/stream_pipe.cc
+++ b/src/stream_pipe.cc
@@ -57,9 +57,11 @@ void StreamPipe::Unpipe() {
   if (is_closed_)
     return;
 
-  // Note that we cannot use virtual methods on `source` and `sink` here,
-  // because this function can be called from their destructors via
+  // Note that we possibly cannot use virtual methods on `source` and `sink`
+  // here, because this function can be called from their destructors via
   // `OnStreamDestroy()`.
+  if (!source_destroyed_)
+    source()->ReadStop();
 
   is_closed_ = true;
   is_reading_ = false;
@@ -144,7 +146,8 @@ void StreamPipe::ProcessData(size_t nread, const uv_buf_t& buf) {
     is_writing_ = true;
     is_reading_ = false;
     res.wrap->SetAllocatedStorage(buf.base, buf.len);
-    source()->ReadStop();
+    if (source() != nullptr)
+      source()->ReadStop();
   }
 }
 
@@ -183,6 +186,7 @@ void StreamPipe::WritableListener::OnStreamAfterShutdown(ShutdownWrap* w,
 
 void StreamPipe::ReadableListener::OnStreamDestroy() {
   StreamPipe* pipe = ContainerOf(&StreamPipe::readable_listener_, this);
+  pipe->source_destroyed_ = true;
   if (!pipe->is_eof_) {
     OnStreamRead(UV_EPIPE, uv_buf_init(nullptr, 0));
   }
@@ -190,6 +194,7 @@ void StreamPipe::ReadableListener::OnStreamDestroy() {
 
 void StreamPipe::WritableListener::OnStreamDestroy() {
   StreamPipe* pipe = ContainerOf(&StreamPipe::writable_listener_, this);
+  pipe->sink_destroyed_ = true;
   pipe->is_eof_ = true;
   pipe->Unpipe();
 }
diff --git a/src/stream_pipe.h b/src/stream_pipe.h
index b72a60941b610a..36a0b1dc08106b 100644
--- a/src/stream_pipe.h
+++ b/src/stream_pipe.h
@@ -23,16 +23,18 @@ class StreamPipe : public AsyncWrap {
   }
 
  private:
-  StreamBase* source();
-  StreamBase* sink();
+  inline StreamBase* source();
+  inline StreamBase* sink();
 
-  void ShutdownWritable();
-  void FlushToWritable();
+  inline void ShutdownWritable();
+  inline void FlushToWritable();
 
   bool is_reading_ = false;
   bool is_writing_ = false;
   bool is_eof_ = false;
   bool is_closed_ = true;
+  bool sink_destroyed_ = false;
+  bool source_destroyed_ = false;
 
   // Set a default value so that when we’re coming from Start(), we know
   // that we don’t want to read just yet.
diff --git a/test/parallel/test-http2-respond-with-file-connection-abort.js b/test/parallel/test-http2-respond-with-file-connection-abort.js
new file mode 100644
index 00000000000000..25926b2c9805a3
--- /dev/null
+++ b/test/parallel/test-http2-respond-with-file-connection-abort.js
@@ -0,0 +1,37 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const http2 = require('http2');
+const net = require('net');
+
+const {
+  HTTP2_HEADER_CONTENT_TYPE
+} = http2.constants;
+
+const server = http2.createServer();
+server.on('stream', common.mustCall((stream) => {
+  stream.respondWithFile(process.execPath, {
+    [HTTP2_HEADER_CONTENT_TYPE]: 'application/octet-stream'
+  });
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = http2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('response', common.mustCall(() => {}));
+  req.on('data', common.mustCall(() => {
+    net.Socket.prototype.destroy.call(client.socket);
+    server.close();
+  }));
+  req.end();
+}));
+
+// TODO(addaleax): This is a *hack*. HTTP/2 needs to have a proper way of
+// dealing with this kind of issue.
+process.once('uncaughtException', (err) => {
+  if (err.code === 'ECONNRESET') return;
+  throw err;
+});

From b338ff54bbad0f34400ece8e5587cec59c0df0cf Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 18:32:17 +0200
Subject: [PATCH 104/116] test: add gc tracking to common API

PR-URL: https://github.com/nodejs/node/pull/21794
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/common/README.md           | 15 +++++++++++++++
 test/common/index.js            | 27 +++++++++++++++++++++++++++
 test/parallel/test-common-gc.js | 15 +++++++++++++++
 3 files changed, 57 insertions(+)
 create mode 100644 test/parallel/test-common-gc.js

diff --git a/test/common/README.md b/test/common/README.md
index c0051ad9f7ca6e..41cc88aca10f59 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -322,6 +322,21 @@ otherwise.
 ### noWarnCode
 See `common.expectWarning()` for usage.
 
+### onGC(target, listener)
+* `target` [&lt;Object>]
+* `listener` [&lt;Object>]
+  * `ongc` [&lt;Function>]
+
+Installs a GC listener for the collection of `target`.
+
+This uses `async_hooks` for GC tracking. This means that it enables
+`async_hooks` tracking, which may affect the test functionality. It also
+means that between a `global.gc()` call and the listener being invoked
+a full `setImmediate()` invocation passes.
+
+`listener` is an object to make it easier to use a closure; the target object
+should not be in scope when `listener.ongc()` is created.
+
 ### opensslCli
 * [&lt;boolean>]
 
diff --git a/test/common/index.js b/test/common/index.js
index bf6b1077d1859b..cca289337ef4a2 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -883,3 +883,30 @@ exports.isCPPSymbolsNotMapped = exports.isWindows ||
                                 exports.isAIX ||
                                 exports.isLinuxPPCBE ||
                                 exports.isFreeBSD;
+
+const gcTrackerMap = new WeakMap();
+const gcTrackerTag = 'NODE_TEST_COMMON_GC_TRACKER';
+
+exports.onGC = function(obj, gcListener) {
+  const async_hooks = require('async_hooks');
+
+  const onGcAsyncHook = async_hooks.createHook({
+    init: exports.mustCallAtLeast(function(id, type, trigger, resource) {
+      if (this.trackedId === undefined) {
+        assert.strictEqual(type, gcTrackerTag);
+        this.trackedId = id;
+      }
+    }),
+    destroy(id) {
+      assert.notStrictEqual(this.trackedId, -1);
+      if (id === this.trackedId) {
+        this.gcListener.ongc();
+        onGcAsyncHook.disable();
+      }
+    }
+  }).enable();
+  onGcAsyncHook.gcListener = gcListener;
+
+  gcTrackerMap.set(obj, new async_hooks.AsyncResource(gcTrackerTag));
+  obj = null;
+};
diff --git a/test/parallel/test-common-gc.js b/test/parallel/test-common-gc.js
new file mode 100644
index 00000000000000..210b1d6d5f49ea
--- /dev/null
+++ b/test/parallel/test-common-gc.js
@@ -0,0 +1,15 @@
+'use strict';
+// Flags: --expose-gc
+const common = require('../common');
+
+{
+  const gcListener = { ongc: common.mustCall() };
+  common.onGC({}, gcListener);
+  global.gc();
+}
+
+{
+  const gcListener = { ongc: common.mustNotCall() };
+  common.onGC(process, gcListener);
+  global.gc();
+}

From 174a9db51a96a9cb7ce4216eddd9588147f890e9 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 18:32:35 +0200
Subject: [PATCH 105/116] test: refactor test-net-connect-memleak, move to
 parallel

This enables the test to run as part of the regular test suite.

PR-URL: https://github.com/nodejs/node/pull/21794
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../test-net-connect-memleak.js               | 46 +++++++++----------
 1 file changed, 23 insertions(+), 23 deletions(-)
 rename test/{pummel => parallel}/test-net-connect-memleak.js (64%)

diff --git a/test/pummel/test-net-connect-memleak.js b/test/parallel/test-net-connect-memleak.js
similarity index 64%
rename from test/pummel/test-net-connect-memleak.js
rename to test/parallel/test-net-connect-memleak.js
index 7546a6caeb62ea..afcc61f173509f 100644
--- a/test/pummel/test-net-connect-memleak.js
+++ b/test/parallel/test-net-connect-memleak.js
@@ -26,32 +26,32 @@ const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-console.log('Run this test with --expose-gc');
-assert.strictEqual(
-  typeof global.gc,
-  'function'
-);
-net.createServer(function() {}).listen(common.PORT);
-
-let before = 0;
+// Test that the implicit listener for an 'connect' event on net.Sockets is
+// added using `once()`, i.e. can be gc'ed once that event has occurred.
+
+const server = net.createServer(common.mustCall()).listen(0);
+
+let collected = false;
+const gcListener = { ongc() { collected = true; } };
+
 {
-  // 2**26 == 64M entries
-  global.gc();
-  const junk = new Array(2 ** 26).fill(0);
-  before = process.memoryUsage().rss;
+  const gcObject = {};
+  common.onGC(gcObject, gcListener);
 
-  net.createConnection(common.PORT, '127.0.0.1', function() {
-    assert.notStrictEqual(junk.length, 0);  // keep reference alive
-    setTimeout(done, 10);
-    global.gc();
-  });
+  const sock = net.createConnection(
+    server.address().port,
+    common.mustCall(() => {
+      assert.strictEqual(gcObject, gcObject); // keep reference alive
+      assert.strictEqual(collected, false);
+      setImmediate(done, sock);
+    }));
 }
 
-function done() {
+function done(sock) {
   global.gc();
-  const after = process.memoryUsage().rss;
-  const reclaimed = (before - after) / 1024;
-  console.log('%d kB reclaimed', reclaimed);
-  assert(reclaimed > 128 * 1024);  // It's around 256 MB on x64.
-  process.exit();
+  setImmediate(() => {
+    assert.strictEqual(collected, true);
+    sock.end();
+    server.close();
+  });
 }

From 6b72583bf8b5d0cfe96b619bccd94e537b0f9639 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 18:32:35 +0200
Subject: [PATCH 106/116] test: refactor test-tls-connect-memleak, move to
 parallel

This enables the test to run as part of the regular test suite.

PR-URL: https://github.com/nodejs/node/pull/21794
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../test-tls-connect-memleak.js               | 46 +++++++++----------
 1 file changed, 23 insertions(+), 23 deletions(-)
 rename test/{pummel => parallel}/test-tls-connect-memleak.js (65%)

diff --git a/test/pummel/test-tls-connect-memleak.js b/test/parallel/test-tls-connect-memleak.js
similarity index 65%
rename from test/pummel/test-tls-connect-memleak.js
rename to test/parallel/test-tls-connect-memleak.js
index 6809b23baf3926..95f71acdc3b57b 100644
--- a/test/pummel/test-tls-connect-memleak.js
+++ b/test/parallel/test-tls-connect-memleak.js
@@ -30,36 +30,36 @@ const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-assert.strictEqual(
-  typeof global.gc,
-  'function',
-  `Type of global.gc is not a function. Type: ${typeof global.gc}.` +
-    ' Run this test with --expose-gc'
-);
+// Test that the implicit listener for an 'connect' event on tls.Sockets is
+// added using `once()`, i.e. can be gc'ed once that event has occurred.
 
-tls.createServer({
+const server = tls.createServer({
   cert: fixtures.readSync('test_cert.pem'),
   key: fixtures.readSync('test_key.pem')
-}).listen(common.PORT);
+}).listen(0);
+
+let collected = false;
+const gcListener = { ongc() { collected = true; } };
 
 {
-  // 2**26 == 64M entries
-  const junk = new Array(2 ** 26).fill(0);
+  const gcObject = {};
+  common.onGC(gcObject, gcListener);
 
-  const options = { rejectUnauthorized: false };
-  tls.connect(common.PORT, '127.0.0.1', options, function() {
-    assert.notStrictEqual(junk.length, 0);  // keep reference alive
-    setTimeout(done, 10);
-    global.gc();
-  });
+  const sock = tls.connect(
+    server.address().port,
+    { rejectUnauthorized: false },
+    common.mustCall(() => {
+      assert.strictEqual(gcObject, gcObject); // keep reference alive
+      assert.strictEqual(collected, false);
+      setImmediate(done, sock);
+    }));
 }
 
-function done() {
-  const before = process.memoryUsage().rss;
+function done(sock) {
   global.gc();
-  const after = process.memoryUsage().rss;
-  const reclaimed = (before - after) / 1024;
-  console.log('%d kB reclaimed', reclaimed);
-  assert(reclaimed > 256 * 1024);  // it's more like 512M on x64
-  process.exit();
+  setImmediate(() => {
+    assert.strictEqual(collected, true);
+    sock.end();
+    server.close();
+  });
 }

From 67908e993302807bb1c7986a090648b56ac2d7ae Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 20:03:17 +0200
Subject: [PATCH 107/116] test: fix build warnings in bigint N-API test

PR-URL: https://github.com/nodejs/node/pull/21796
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_bigint/test_bigint.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/addons-napi/test_bigint/test_bigint.c b/test/addons-napi/test_bigint/test_bigint.c
index e3516628e88b35..b1e6c359db6add 100644
--- a/test/addons-napi/test_bigint/test_bigint.c
+++ b/test/addons-napi/test_bigint/test_bigint.c
@@ -8,7 +8,7 @@
 static napi_value IsLossless(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &args, NULL, NULL));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   bool is_signed;
   NAPI_CALL(env, napi_get_value_bool(env, args[1], &is_signed));
@@ -98,7 +98,7 @@ static napi_value TestWords(napi_env env, napi_callback_info info) {
   uint64_t words[10];
 
   NAPI_CALL(env, napi_get_value_bigint_words(
-        env, args[0], &sign_bit, &word_count, &words));
+        env, args[0], &sign_bit, &word_count, words));
 
   NAPI_ASSERT(env, word_count == expected_word_count,
       "word counts do not match");

From 4ed4bf3bdd2e8ce11b89aa07c0358ada58ba653d Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Wed, 11 Jul 2018 10:57:46 -0700
Subject: [PATCH 108/116] lib: update punycode to 2.1.1

PR-URL: https://github.com/nodejs/node/pull/21768
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 lib/punycode.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/punycode.js b/lib/punycode.js
index 34da3ca5ad13b6..ea61fd0d39a39d 100644
--- a/lib/punycode.js
+++ b/lib/punycode.js
@@ -15,7 +15,7 @@ const delimiter = '-'; // '\x2D'
 
 /** Regular expressions */
 const regexPunycode = /^xn--/;
-const regexNonASCII = /[^\x20-\x7E]/; // unprintable ASCII chars + non-ASCII chars
+const regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars
 const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
 
 /** Error messages */
@@ -210,7 +210,7 @@ const decode = function(input) {
 		basic = 0;
 	}
 
-	for (var j = 0; j < basic; ++j) {
+	for (let j = 0; j < basic; ++j) {
 		// if it's not a basic code point
 		if (input.charCodeAt(j) >= 0x80) {
 			error('not-basic');
@@ -221,7 +221,7 @@ const decode = function(input) {
 	// Main decoding loop: start just after the last delimiter if any basic code
 	// points were copied; start at the beginning otherwise.
 
-	for (var index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+	for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
 
 		// `index` is the index of the next character to be consumed.
 		// Decode a generalized variable-length integer into `delta`,
@@ -229,7 +229,7 @@ const decode = function(input) {
 		// if we increase `i` as we go, then subtract off its starting
 		// value at the end to obtain `delta`.
 		let oldi = i;
-		for (var w = 1, k = base; /* no condition */; k += base) {
+		for (let w = 1, k = base; /* no condition */; k += base) {
 
 			if (index >= inputLength) {
 				error('invalid-input');
@@ -345,7 +345,7 @@ const encode = function(input) {
 			if (currentValue == n) {
 				// Represent delta as a generalized variable-length integer.
 				let q = delta;
-				for (var k = base; /* no condition */; k += base) {
+				for (let k = base; /* no condition */; k += base) {
 					const t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
 					if (q < t) {
 						break;
@@ -419,7 +419,7 @@ const punycode = {
 	 * @memberOf punycode
 	 * @type String
 	 */
-	'version': '2.0.0',
+	'version': '2.1.0',
 	/**
 	 * An object of methods to convert from JavaScript's internal character
 	 * representation (UCS-2) to Unicode code points, and back.

From eef975ebae7a166b41f8dd2e65aec9aa0b5a5fc4 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 13 Jul 2018 20:49:16 +0200
Subject: [PATCH 109/116] test: move inspector test back to parallel, unmark
 flaky
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

After https://github.com/nodejs/node/pull/21182, the test is
no longer flaky.

Since it doesn’t use a static port, moving it to parallel
seems justified.

PR-URL: https://github.com/nodejs/node/pull/21806
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 .../{sequential => parallel}/test-inspector-port-zero-cluster.js | 0
 test/sequential/sequential.status                                | 1 -
 2 files changed, 1 deletion(-)
 rename test/{sequential => parallel}/test-inspector-port-zero-cluster.js (100%)

diff --git a/test/sequential/test-inspector-port-zero-cluster.js b/test/parallel/test-inspector-port-zero-cluster.js
similarity index 100%
rename from test/sequential/test-inspector-port-zero-cluster.js
rename to test/parallel/test-inspector-port-zero-cluster.js
diff --git a/test/sequential/sequential.status b/test/sequential/sequential.status
index 59cc2bc7f77881..c5873b9060f8fe 100644
--- a/test/sequential/sequential.status
+++ b/test/sequential/sequential.status
@@ -16,7 +16,6 @@ test-inspector-bindings                  : PASS, FLAKY
 test-inspector-debug-end                 : PASS, FLAKY
 
 [$system==linux]
-test-inspector-port-zero-cluster         :  PASS, FLAKY
 
 [$system==macos]
 

From 581390c59d2a003bc7fcc7d3727dce2dafde21fd Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Mon, 18 Jun 2018 00:40:58 +0800
Subject: [PATCH 110/116] process: split bootstrappers by threads that can run
 them
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch split part of the bootstrappers into three files:

- `lib/internal/process/main_thread_only.js`: contains bootstrappers
  that can only be run in the main thread, including
  - `setupStdio` for the main thread that sets up `process.stdin`,
    `process.stdout`, `process.error` that may interact with external
    resources, e.g. TTY/File/Pipe/TCP sockets
  - `setupProcessMethods` that setup methods changing process-global
    states, e.g. `process.chdir`, `process.umask`, `process.setuid`
  - `setupSignalHandlers`
  - `setupChildProcessIpcChannel` that setup `process.send` for
    child processes.
- `lib/internal/process/worker_thread_only.js`: contains bootstrappers
  that can only be run in the worker threads, including
  - `setupStdio` for the worker thread that are streams to be
    manipulated or piped to the parent thread
- `lib/internal/process/per_thread.js`: contains bootstrappers
    that can be run in all threads, including:
  - `setupAssert` for `process.assert`
  - `setupCpuUsage` for `process.cpuUsage`
  - `setupHrtime` for `process.hrtime` and `process.hrtime.bigint`
  - `setupMemoryUsage` for `process.memoryUsage`
  - `setupConfig` for `process.config`
  - `setupKillAndExit` for `process.kill` and `process.exit`
  - `setupRawDebug` for `process._rawDebug`
  - `setupUncaughtExceptionCapture` for
    `process.setUncaughtExceptionCaptureCallback` and
    `process.hasUncaughtExceptionCaptureCallback`

Hopefully in the future we can sort more bootstrappers in
`boostrap/node.js` into these three files and further group
them into functions that can be run before creating the
snapshot / after loading the snapshot.

This patch also moves most of the `isMainThread` conditionals
into the main bootstrapper instead of letting them scattered around
special-casing different implementations.

PR-URL: https://github.com/nodejs/node/pull/21378
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>

Backport-PR-URL: https://github.com/nodejs/node/pull/21866
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 lib/internal/bootstrap/node.js                |  67 ++++++---
 lib/internal/process/main_thread_only.js      | 127 ++++++++++++++++++
 lib/internal/process/methods.js               |  56 --------
 .../{process.js => process/per_thread.js}     |  92 +++----------
 lib/internal/process/stdio.js                 |  21 +--
 lib/internal/process/worker_thread_only.js    |  24 ++++
 node.gyp                                      |   5 +-
 7 files changed, 227 insertions(+), 165 deletions(-)
 create mode 100644 lib/internal/process/main_thread_only.js
 delete mode 100644 lib/internal/process/methods.js
 rename lib/internal/{process.js => process/per_thread.js} (75%)
 create mode 100644 lib/internal/process/worker_thread_only.js

diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 61146a32aad010..ab1695125df6bc 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -44,33 +44,57 @@
 
     setupGlobalVariables();
 
-    const _process = NativeModule.require('internal/process');
-    _process.setupConfig(NativeModule._source);
-    _process.setupSignalHandlers();
-    _process.setupUncaughtExceptionCapture(exceptionHandlerState,
-                                           _shouldAbortOnUncaughtToggle);
+    // Bootstrappers for all threads, including worker threads and main thread
+    const perThreadSetup = NativeModule.require('internal/process/per_thread');
+    // Bootstrappers for the main thread only
+    let mainThreadSetup;
+    // Bootstrappers for the worker threads only
+    let workerThreadSetup;
+    if (isMainThread) {
+      mainThreadSetup = NativeModule.require(
+        'internal/process/main_thread_only'
+      );
+    } else {
+      workerThreadSetup = NativeModule.require(
+        'internal/process/worker_thread_only'
+      );
+    }
+
+    perThreadSetup.setupAssert();
+    perThreadSetup.setupConfig(NativeModule._source);
+
+    if (isMainThread) {
+      mainThreadSetup.setupSignalHandlers();
+    }
+
+    perThreadSetup.setupUncaughtExceptionCapture(exceptionHandlerState,
+                                                 _shouldAbortOnUncaughtToggle);
+
     NativeModule.require('internal/process/warning').setup();
     NativeModule.require('internal/process/next_tick').setup(_setupNextTick,
                                                              _setupPromises);
-    NativeModule.require('internal/process/stdio').setup();
-    NativeModule.require('internal/process/methods').setup(_chdir,
-                                                           _umask,
-                                                           _initgroups,
-                                                           _setegid,
-                                                           _seteuid,
-                                                           _setgid,
-                                                           _setuid,
-                                                           _setgroups);
+
+    if (isMainThread) {
+      mainThreadSetup.setupStdio();
+      mainThreadSetup.setupProcessMethods(
+        _chdir, _umask, _initgroups, _setegid, _seteuid,
+        _setgid, _setuid, _setgroups
+      );
+    } else {
+      workerThreadSetup.setupStdio();
+    }
 
     const perf = process.binding('performance');
     const {
       NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE,
     } = perf.constants;
 
-    _process.setup_hrtime(_hrtime, _hrtimeBigInt);
-    _process.setup_cpuUsage(_cpuUsage);
-    _process.setupMemoryUsage(_memoryUsage);
-    _process.setupKillAndExit();
+    perThreadSetup.setupRawDebug(_rawDebug);
+    perThreadSetup.setupHrtime(_hrtime, _hrtimeBigInt);
+    perThreadSetup.setupCpuUsage(_cpuUsage);
+    perThreadSetup.setupMemoryUsage(_memoryUsage);
+    perThreadSetup.setupKillAndExit();
+
     if (global.__coverage__)
       NativeModule.require('internal/process/write-coverage').setup();
 
@@ -90,10 +114,9 @@
       NativeModule.require('internal/inspector_async_hook').setup();
     }
 
-    if (isMainThread)
-      _process.setupChannel();
-
-    _process.setupRawDebug(_rawDebug);
+    if (isMainThread) {
+      mainThreadSetup.setupChildProcessIpcChannel();
+    }
 
     const browserGlobals = !process._noBrowserGlobals;
     if (browserGlobals) {
diff --git a/lib/internal/process/main_thread_only.js b/lib/internal/process/main_thread_only.js
new file mode 100644
index 00000000000000..814cca266d6675
--- /dev/null
+++ b/lib/internal/process/main_thread_only.js
@@ -0,0 +1,127 @@
+'use strict';
+
+// This file contains process bootstrappers that can only be
+// run in the main thread
+
+const {
+  errnoException
+} = require('internal/errors');
+
+const {
+  setupProcessStdio,
+  getMainThreadStdio
+} = require('internal/process/stdio');
+
+const assert = require('assert').strict;
+
+function setupStdio() {
+  setupProcessStdio(getMainThreadStdio());
+}
+
+// Non-POSIX platforms like Windows don't have certain methods.
+// Workers also lack these methods since they change process-global state.
+function setupProcessMethods(_chdir, _umask, _initgroups, _setegid,
+                             _seteuid, _setgid, _setuid, _setgroups) {
+  if (_setgid !== undefined) {
+    setupPosixMethods(_initgroups, _setegid, _seteuid,
+                      _setgid, _setuid, _setgroups);
+  }
+
+  process.chdir = function chdir(...args) {
+    return _chdir(...args);
+  };
+
+  process.umask = function umask(...args) {
+    return _umask(...args);
+  };
+}
+
+function setupPosixMethods(_initgroups, _setegid, _seteuid,
+                           _setgid, _setuid, _setgroups) {
+
+  process.initgroups = function initgroups(...args) {
+    return _initgroups(...args);
+  };
+
+  process.setegid = function setegid(...args) {
+    return _setegid(...args);
+  };
+
+  process.seteuid = function seteuid(...args) {
+    return _seteuid(...args);
+  };
+
+  process.setgid = function setgid(...args) {
+    return _setgid(...args);
+  };
+
+  process.setuid = function setuid(...args) {
+    return _setuid(...args);
+  };
+
+  process.setgroups = function setgroups(...args) {
+    return _setgroups(...args);
+  };
+}
+
+// Worker threads don't receive signals.
+function setupSignalHandlers() {
+  const constants = process.binding('constants').os.signals;
+  const signalWraps = Object.create(null);
+  let Signal;
+
+  function isSignal(event) {
+    return typeof event === 'string' && constants[event] !== undefined;
+  }
+
+  // Detect presence of a listener for the special signal types
+  process.on('newListener', function(type) {
+    if (isSignal(type) && signalWraps[type] === undefined) {
+      if (Signal === undefined)
+        Signal = process.binding('signal_wrap').Signal;
+      const wrap = new Signal();
+
+      wrap.unref();
+
+      wrap.onsignal = process.emit.bind(process, type, type);
+
+      const signum = constants[type];
+      const err = wrap.start(signum);
+      if (err) {
+        wrap.close();
+        throw errnoException(err, 'uv_signal_start');
+      }
+
+      signalWraps[type] = wrap;
+    }
+  });
+
+  process.on('removeListener', function(type) {
+    if (signalWraps[type] !== undefined && this.listenerCount(type) === 0) {
+      signalWraps[type].close();
+      delete signalWraps[type];
+    }
+  });
+}
+
+function setupChildProcessIpcChannel() {
+  // If we were spawned with env NODE_CHANNEL_FD then load that up and
+  // start parsing data from that stream.
+  if (process.env.NODE_CHANNEL_FD) {
+    const fd = parseInt(process.env.NODE_CHANNEL_FD, 10);
+    assert(fd >= 0);
+
+    // Make sure it's not accidentally inherited by child processes.
+    delete process.env.NODE_CHANNEL_FD;
+
+    require('child_process')._forkChild(fd);
+    assert(process.send);
+  }
+}
+
+module.exports = {
+  setupStdio,
+  setupProcessMethods,
+  setupSignalHandlers,
+  setupChildProcessIpcChannel
+};
diff --git a/lib/internal/process/methods.js b/lib/internal/process/methods.js
deleted file mode 100644
index 38ba5f84b5a30a..00000000000000
--- a/lib/internal/process/methods.js
+++ /dev/null
@@ -1,56 +0,0 @@
-'use strict';
-
-const {
-  isMainThread
-} = require('internal/worker');
-
-function setupProcessMethods(_chdir, _umask, _initgroups, _setegid,
-                             _seteuid, _setgid, _setuid, _setgroups) {
-  // Non-POSIX platforms like Windows don't have certain methods.
-  // Workers also lack these methods since they change process-global state.
-  if (!isMainThread)
-    return;
-
-  if (_setgid !== undefined) {
-    setupPosixMethods(_initgroups, _setegid, _seteuid,
-                      _setgid, _setuid, _setgroups);
-  }
-
-  process.chdir = function chdir(...args) {
-    return _chdir(...args);
-  };
-
-  process.umask = function umask(...args) {
-    return _umask(...args);
-  };
-}
-
-function setupPosixMethods(_initgroups, _setegid, _seteuid,
-                           _setgid, _setuid, _setgroups) {
-
-  process.initgroups = function initgroups(...args) {
-    return _initgroups(...args);
-  };
-
-  process.setegid = function setegid(...args) {
-    return _setegid(...args);
-  };
-
-  process.seteuid = function seteuid(...args) {
-    return _seteuid(...args);
-  };
-
-  process.setgid = function setgid(...args) {
-    return _setgid(...args);
-  };
-
-  process.setuid = function setuid(...args) {
-    return _setuid(...args);
-  };
-
-  process.setgroups = function setgroups(...args) {
-    return _setgroups(...args);
-  };
-}
-
-exports.setup = setupProcessMethods;
diff --git a/lib/internal/process.js b/lib/internal/process/per_thread.js
similarity index 75%
rename from lib/internal/process.js
rename to lib/internal/process/per_thread.js
index 098edaeaaff183..fbf60bac6e9fff 100644
--- a/lib/internal/process.js
+++ b/lib/internal/process/per_thread.js
@@ -1,5 +1,9 @@
 'use strict';
 
+// This files contains process bootstrappers that can be
+// run when setting up each thread, including the main
+// thread and the worker threads.
+
 const {
   errnoException,
   codes: {
@@ -14,19 +18,19 @@ const {
 } = require('internal/errors');
 const util = require('util');
 const constants = process.binding('constants').os.signals;
-const assert = require('assert').strict;
 const { deprecate } = require('internal/util');
-const { isMainThread } = require('internal/worker');
 
-process.assert = deprecate(
-  function(x, msg) {
-    if (!x) throw new ERR_ASSERTION(msg || 'assertion error');
-  },
-  'process.assert() is deprecated. Please use the `assert` module instead.',
-  'DEP0100');
+function setupAssert() {
+  process.assert = deprecate(
+    function(x, msg) {
+      if (!x) throw new ERR_ASSERTION(msg || 'assertion error');
+    },
+    'process.assert() is deprecated. Please use the `assert` module instead.',
+    'DEP0100');
+}
 
 // Set up the process.cpuUsage() function.
-function setup_cpuUsage(_cpuUsage) {
+function setupCpuUsage(_cpuUsage) {
   // Create the argument array that will be passed to the native function.
   const cpuValues = new Float64Array(2);
 
@@ -90,7 +94,7 @@ function setup_cpuUsage(_cpuUsage) {
 // The 3 entries filled in by the original process.hrtime contains
 // the upper/lower 32 bits of the second part of the value,
 // and the remaining nanoseconds of the value.
-function setup_hrtime(_hrtime, _hrtimeBigInt) {
+function setupHrtime(_hrtime, _hrtimeBigInt) {
   const hrValues = new Uint32Array(3);
 
   process.hrtime = function hrtime(time) {
@@ -193,67 +197,6 @@ function setupKillAndExit() {
   };
 }
 
-
-function setupSignalHandlers() {
-  if (!isMainThread) {
-    // Worker threads don't receive signals.
-    return;
-  }
-
-  const signalWraps = Object.create(null);
-  let Signal;
-
-  function isSignal(event) {
-    return typeof event === 'string' && constants[event] !== undefined;
-  }
-
-  // Detect presence of a listener for the special signal types
-  process.on('newListener', function(type) {
-    if (isSignal(type) && signalWraps[type] === undefined) {
-      if (Signal === undefined)
-        Signal = process.binding('signal_wrap').Signal;
-      const wrap = new Signal();
-
-      wrap.unref();
-
-      wrap.onsignal = process.emit.bind(process, type, type);
-
-      const signum = constants[type];
-      const err = wrap.start(signum);
-      if (err) {
-        wrap.close();
-        throw errnoException(err, 'uv_signal_start');
-      }
-
-      signalWraps[type] = wrap;
-    }
-  });
-
-  process.on('removeListener', function(type) {
-    if (signalWraps[type] !== undefined && this.listenerCount(type) === 0) {
-      signalWraps[type].close();
-      delete signalWraps[type];
-    }
-  });
-}
-
-
-function setupChannel() {
-  // If we were spawned with env NODE_CHANNEL_FD then load that up and
-  // start parsing data from that stream.
-  if (process.env.NODE_CHANNEL_FD) {
-    const fd = parseInt(process.env.NODE_CHANNEL_FD, 10);
-    assert(fd >= 0);
-
-    // Make sure it's not accidentally inherited by child processes.
-    delete process.env.NODE_CHANNEL_FD;
-
-    require('child_process')._forkChild(fd);
-    assert(process.send);
-  }
-}
-
-
 function setupRawDebug(_rawDebug) {
   process._rawDebug = function() {
     _rawDebug(util.format.apply(null, arguments));
@@ -288,13 +231,12 @@ function setupUncaughtExceptionCapture(exceptionHandlerState,
 }
 
 module.exports = {
-  setup_cpuUsage,
-  setup_hrtime,
+  setupAssert,
+  setupCpuUsage,
+  setupHrtime,
   setupMemoryUsage,
   setupConfig,
   setupKillAndExit,
-  setupSignalHandlers,
-  setupChannel,
   setupRawDebug,
   setupUncaughtExceptionCapture
 };
diff --git a/lib/internal/process/stdio.js b/lib/internal/process/stdio.js
index f4a07cd06d09d9..e4207a1aa768bd 100644
--- a/lib/internal/process/stdio.js
+++ b/lib/internal/process/stdio.js
@@ -6,21 +6,17 @@ const {
   ERR_UNKNOWN_STDIN_TYPE,
   ERR_UNKNOWN_STREAM_TYPE
 } = require('internal/errors').codes;
-const {
-  isMainThread,
-  workerStdio
-} = require('internal/worker');
 
-exports.setup = setupStdio;
+exports.setupProcessStdio = setupProcessStdio;
+exports.getMainThreadStdio = getMainThreadStdio;
 
-function setupStdio() {
+function getMainThreadStdio() {
   var stdin;
   var stdout;
   var stderr;
 
   function getStdout() {
     if (stdout) return stdout;
-    if (!isMainThread) return workerStdio.stdout;
     stdout = createWritableStdioStream(1);
     stdout.destroySoon = stdout.destroy;
     stdout._destroy = function(er, cb) {
@@ -36,7 +32,6 @@ function setupStdio() {
 
   function getStderr() {
     if (stderr) return stderr;
-    if (!isMainThread) return workerStdio.stderr;
     stderr = createWritableStdioStream(2);
     stderr.destroySoon = stderr.destroy;
     stderr._destroy = function(er, cb) {
@@ -52,8 +47,6 @@ function setupStdio() {
 
   function getStdin() {
     if (stdin) return stdin;
-    if (!isMainThread) return workerStdio.stdin;
-
     const tty_wrap = process.binding('tty_wrap');
     const fd = 0;
 
@@ -136,6 +129,14 @@ function setupStdio() {
     return stdin;
   }
 
+  return {
+    getStdout,
+    getStderr,
+    getStdin
+  };
+}
+
+function setupProcessStdio({ getStdout, getStdin, getStderr }) {
   Object.defineProperty(process, 'stdout', {
     configurable: true,
     enumerable: true,
diff --git a/lib/internal/process/worker_thread_only.js b/lib/internal/process/worker_thread_only.js
new file mode 100644
index 00000000000000..834ba6078fca44
--- /dev/null
+++ b/lib/internal/process/worker_thread_only.js
@@ -0,0 +1,24 @@
+'use strict';
+
+// This file contains process bootstrappers that can only be
+// run in the worker thread.
+
+const {
+  setupProcessStdio
+} = require('internal/process/stdio');
+
+const {
+  workerStdio
+} = require('internal/worker');
+
+function setupStdio() {
+  setupProcessStdio({
+    getStdout: () => workerStdio.stdout,
+    getStderr: () => workerStdio.stderr,
+    getStdin: () => workerStdio.stdin
+  });
+}
+
+module.exports = {
+  setupStdio
+};
diff --git a/node.gyp b/node.gyp
index 04784715c34f86..56315baf7006b3 100644
--- a/node.gyp
+++ b/node.gyp
@@ -133,12 +133,13 @@
       'lib/internal/net.js',
       'lib/internal/os.js',
       'lib/internal/process/esm_loader.js',
-      'lib/internal/process/methods.js',
+      'lib/internal/process/main_thread_only.js',
       'lib/internal/process/next_tick.js',
+      'lib/internal/process/per_thread.js',
       'lib/internal/process/promises.js',
       'lib/internal/process/stdio.js',
       'lib/internal/process/warning.js',
-      'lib/internal/process.js',
+      'lib/internal/process/worker_thread_only.js',
       'lib/internal/querystring.js',
       'lib/internal/process/write-coverage.js',
       'lib/internal/readline.js',

From 576f1ea9782bbd8594e88b21dd0f168275c80e83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= <tniessen@tnie.de>
Date: Tue, 17 Jul 2018 02:38:34 +0200
Subject: [PATCH 111/116] buffer: remove superfluous assignment
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/21844
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Yuta Hiroto <hello@hiroppy.me>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_buffer.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 6e25889d6e4a25..858852e748fe03 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -612,7 +612,6 @@ void Fill(const FunctionCallbackInfo<Value>& args) {
     memcpy(ts_obj_data + start, *str, MIN(str_length, fill_length));
 
   } else {
-    str_length = str_obj->Length();
     // Write initial String to Buffer, then use that memory to copy remainder
     // of string. Correct the string length for cases like HEX where less than
     // the total string length is written.

From d9825c7a16cae44e3efb2b3d7891a7f05e4c093e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= <tniessen@tnie.de>
Date: Sat, 14 Jul 2018 18:59:39 +0200
Subject: [PATCH 112/116] crypto: prevent Sign::SignFinal from crashing

The validation logic could be tricked into assuming an option was
valid using malicious getters, leading to an invalid value being
passed to the C++ layer, thus crashing the process.

PR-URL: https://github.com/nodejs/node/pull/21815
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
---
 lib/internal/crypto/sig.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/internal/crypto/sig.js b/lib/internal/crypto/sig.js
index b6f8ceb50186d1..8aff7354735404 100644
--- a/lib/internal/crypto/sig.js
+++ b/lib/internal/crypto/sig.js
@@ -57,10 +57,11 @@ function getSaltLength(options) {
 
 function getIntOption(name, defaultValue, options) {
   if (options.hasOwnProperty(name)) {
-    if (options[name] === options[name] >> 0) {
-      return options[name];
+    const value = options[name];
+    if (value === value >> 0) {
+      return value;
     } else {
-      throw new ERR_INVALID_OPT_VALUE(name, options[name]);
+      throw new ERR_INVALID_OPT_VALUE(name, value);
     }
   }
   return defaultValue;

From 0108ff6b51e7d46f1d4126f3a334d9bdbe31d8f4 Mon Sep 17 00:00:00 2001
From: Antoine du HAMEL <duhamelantoine1995@gmail.com>
Date: Wed, 27 Jun 2018 00:51:21 +0200
Subject: [PATCH 113/116] test: add support for NODE_TEST_DIR on a separate
 mount point

Linux permits a filesystem to be mounted at multiple points, but
`fs.renameSync` does not work across different mount points, even if the
same filesystem is mounted on both.
This fixes failing tests when NODE_TEST_DIR mount point is different
from the one on which the tests are executed (E.G. on a separate
partition).

Ref: http://man7.org/linux/man-pages/man2/rename.2.html

PR-URL: https://github.com/nodejs/node/pull/21552
Refs: http://man7.org/linux/man-pages/man2/rename.2.html
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Ben Coe <bencoe@gmail.com>
---
 test/parallel/test-fs-copyfile.js       | 2 +-
 test/parallel/test-fs-error-messages.js | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-fs-copyfile.js b/test/parallel/test-fs-copyfile.js
index 6e5d6c9403e795..f001535598bbeb 100644
--- a/test/parallel/test-fs-copyfile.js
+++ b/test/parallel/test-fs-copyfile.js
@@ -64,7 +64,7 @@ try {
 } catch (err) {
   assert.strictEqual(err.syscall, 'copyfile');
   assert(err.code === 'ENOTSUP' || err.code === 'ENOTTY' ||
-    err.code === 'ENOSYS');
+    err.code === 'ENOSYS' || err.code === 'EXDEV');
   assert.strictEqual(err.path, src);
   assert.strictEqual(err.dest, dest);
 }
diff --git a/test/parallel/test-fs-error-messages.js b/test/parallel/test-fs-error-messages.js
index f406e8743ed120..8ef009e8128b0d 100644
--- a/test/parallel/test-fs-error-messages.js
+++ b/test/parallel/test-fs-error-messages.js
@@ -303,6 +303,11 @@ function re(literals, ...values) {
         `ENOTEMPTY: directory not empty, rename '${existingDir}' -> ` +
         `'${existingDir2}'`);
       assert.strictEqual(err.errno, uv.UV_ENOTEMPTY);
+    } else if (err.code === 'EXDEV') {  // not on the same mounted filesystem
+      assert.strictEqual(
+        err.message,
+        `EXDEV: cross-device link not permitted, rename '${existingDir}' -> ` +
+            `'${existingDir2}'`);
     } else if (err.code === 'EEXIST') {  // smartos and aix
       assert.strictEqual(
         err.message,

From 292202836247f5ff1807a3fb72950d591a0e5cae Mon Sep 17 00:00:00 2001
From: Matteo Collina <hello@matteocollina.com>
Date: Wed, 4 Jul 2018 19:55:12 +0200
Subject: [PATCH 114/116] inspector: expose original console
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds require('inspector').console, mapping it to the original
global.console of V8. This enables applications to send messages to
the inspector console programmatically.

Fixes: https://github.com/nodejs/node/issues/21651

PR-URL: https://github.com/nodejs/node/pull/21659
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/inspector.md                      | 11 +++++++
 lib/inspector.js                          |  2 ++
 lib/internal/bootstrap/node.js            |  2 ++
 test/common/inspector-helper.js           | 10 ++++--
 test/sequential/test-inspector-console.js | 39 +++++++++++++++++++++++
 5 files changed, 62 insertions(+), 2 deletions(-)
 create mode 100644 test/sequential/test-inspector-console.js

diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 7b1adcc47b32a0..8ab827bd1f9145 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -28,6 +28,17 @@ started.
 If wait is `true`, will block until a client has connected to the inspect port
 and flow control has been passed to the debugger client.
 
+### inspector.console
+
+An object to send messages to the remote inspector console.
+
+```js
+require('inspector').console.log('a message');
+```
+
+The inspector console does not have API parity with Node.js
+console.
+
 ### inspector.close()
 
 Deactivate the inspector. Blocks until there are no active connections.
diff --git a/lib/inspector.js b/lib/inspector.js
index f4ec71fd6c2105..f4e365b774be79 100644
--- a/lib/inspector.js
+++ b/lib/inspector.js
@@ -11,6 +11,7 @@ const {
 } = require('internal/errors').codes;
 const util = require('util');
 const { Connection, open, url } = process.binding('inspector');
+const { originalConsole } = require('internal/process/per_thread');
 
 if (!Connection || !require('internal/worker').isMainThread)
   throw new ERR_INSPECTOR_NOT_AVAILABLE();
@@ -103,5 +104,6 @@ module.exports = {
   open: (port, host, wait) => open(port, host, !!wait),
   close: process._debugEnd,
   url: url,
+  console: originalConsole,
   Session
 };
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index ab1695125df6bc..016c0c5e2304bc 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -120,6 +120,8 @@
 
     const browserGlobals = !process._noBrowserGlobals;
     if (browserGlobals) {
+      // we are setting this here to foward it to the inspector later
+      perThreadSetup.originalConsole = global.console;
       setupGlobalTimeouts();
       setupGlobalConsole();
       setupGlobalURL();
diff --git a/test/common/inspector-helper.js b/test/common/inspector-helper.js
index e590349f9c2b71..13726049798f0e 100644
--- a/test/common/inspector-helper.js
+++ b/test/common/inspector-helper.js
@@ -7,6 +7,7 @@ const fixtures = require('../common/fixtures');
 const { spawn } = require('child_process');
 const { parse: parseURL } = require('url');
 const { getURLFromFilePath } = require('internal/url');
+const { EventEmitter } = require('events');
 
 const _MAINSCRIPT = fixtures.path('loop.js');
 const DEBUG = false;
@@ -311,10 +312,12 @@ class InspectorSession {
   }
 }
 
-class NodeInstance {
+class NodeInstance extends EventEmitter {
   constructor(inspectorFlags = ['--inspect-brk=0'],
               scriptContents = '',
               scriptFile = _MAINSCRIPT) {
+    super();
+
     this._scriptPath = scriptFile;
     this._script = scriptFile ? null : scriptContents;
     this._portCallback = null;
@@ -326,7 +329,10 @@ class NodeInstance {
     this._unprocessedStderrLines = [];
 
     this._process.stdout.on('data', makeBufferingDataCallback(
-      (line) => console.log('[out]', line)));
+      (line) => {
+        this.emit('stdout', line);
+        console.log('[out]', line);
+      }));
 
     this._process.stderr.on('data', makeBufferingDataCallback(
       (message) => this.onStderrLine(message)));
diff --git a/test/sequential/test-inspector-console.js b/test/sequential/test-inspector-console.js
new file mode 100644
index 00000000000000..6a06c798881654
--- /dev/null
+++ b/test/sequential/test-inspector-console.js
@@ -0,0 +1,39 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const { NodeInstance } = require('../common/inspector-helper.js');
+const assert = require('assert');
+
+async function runTest() {
+  const script = 'require(\'inspector\').console.log(\'hello world\');';
+  const child = new NodeInstance('--inspect-brk=0', script, '');
+
+  let out = '';
+  child.on('stdout', (line) => out += line);
+
+  const session = await child.connectInspectorSession();
+
+  const commands = [
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Runtime.runIfWaitingForDebugger' }
+  ];
+
+  session.send(commands);
+
+  const msg = await session.waitForNotification('Runtime.consoleAPICalled');
+
+  assert.strictEqual(msg.params.type, 'log');
+  assert.deepStrictEqual(msg.params.args, [{
+    type: 'string',
+    value: 'hello world'
+  }]);
+  assert.strictEqual(out, '');
+
+  session.disconnect();
+}
+
+common.crashOnUnhandledRejection();
+runTest();

From 506631a9f92fa7a519db172f7bc8de0d7e58f596 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Sun, 8 Jul 2018 16:58:40 +0300
Subject: [PATCH 115/116] doc: fix structure and formatting in inspector.md

1. Reorder some sections alphabetically.
2. Fix some heading levels.
3. Express a type of a property more formally.

PR-URL: https://github.com/nodejs/node/pull/21709
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Claudio Rodriguez <cjrodr@yahoo.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
---
 doc/api/inspector.md | 52 ++++++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/doc/api/inspector.md b/doc/api/inspector.md
index 8ab827bd1f9145..92fcb0e03f89e4 100644
--- a/doc/api/inspector.md
+++ b/doc/api/inspector.md
@@ -12,6 +12,21 @@ It can be accessed using:
 const inspector = require('inspector');
 ```
 
+## inspector.close()
+
+Deactivate the inspector. Blocks until there are no active connections.
+
+## inspector.console
+
+* {Object} An object to send messages to the remote inspector console.
+
+```js
+require('inspector').console.log('a message');
+```
+
+The inspector console does not have API parity with Node.js
+console.
+
 ## inspector.open([port[, host[, wait]]])
 
 * `port` {number} Port to listen on for inspector connections. Optional.
@@ -28,22 +43,7 @@ started.
 If wait is `true`, will block until a client has connected to the inspect port
 and flow control has been passed to the debugger client.
 
-### inspector.console
-
-An object to send messages to the remote inspector console.
-
-```js
-require('inspector').console.log('a message');
-```
-
-The inspector console does not have API parity with Node.js
-console.
-
-### inspector.close()
-
-Deactivate the inspector. Blocks until there are no active connections.
-
-### inspector.url()
+## inspector.url()
 
 * Returns: {string|undefined}
 
@@ -112,6 +112,16 @@ Connects a session to the inspector back-end. An exception will be thrown
 if there is already a connected session established either through the API or by
 a front-end connected to the Inspector WebSocket port.
 
+### session.disconnect()
+<!-- YAML
+added: v8.0.0
+-->
+
+Immediately close the session. All pending message callbacks will be called
+with an error. [`session.connect()`] will need to be called to be able to send
+messages again. Reconnected session will lose all inspector state, such as
+enabled agents or configured breakpoints.
+
 ### session.post(method[, params][, callback])
 <!-- YAML
 added: v8.0.0
@@ -139,16 +149,6 @@ by V8. Chrome DevTools Protocol domain provides an interface for interacting
 with one of the runtime agents used to inspect the application state and listen
 to the run-time events.
 
-### session.disconnect()
-<!-- YAML
-added: v8.0.0
--->
-
-Immediately close the session. All pending message callbacks will be called
-with an error. [`session.connect()`] will need to be called to be able to send
-messages again. Reconnected session will lose all inspector state, such as
-enabled agents or configured breakpoints.
-
 ## Example usage
 
 ### CPU Profiler

From 991bb95384214639a1afe2dc4599768ebceab3ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Tue, 17 Jul 2018 16:33:02 +0200
Subject: [PATCH 116/116] 2018-07-18, Version 10.7.0 (Current)

Notable changes:

* console:
  * The `console.timeLog()` method has been implemented.
    (https://github.com/nodejs/node/pull/21312)
* deps:
  * Upgrade to libuv 1.22.0. (https://github.com/nodejs/node/pull/21731)
  * Upgrade to ICU 62.1 (Unicode 11, CLDR 33.1).
    (https://github.com/nodejs/node/pull/21728)
* http:
  * Added support for passing both `timeout` and `agent` options to
    `http.request`. (https://github.com/nodejs/node/pull/21204)
* inspector:
  * Expose the original console API in `require('inspector').console`.
    (https://github.com/nodejs/node/pull/21659)
* napi:
  * Added experimental support for functions dealing with bigint numbers.
    (https://github.com/nodejs/node/pull/21226)
* process:
  * The `process.hrtime.bigint()` method has been implemented.
    (https://github.com/nodejs/node/pull/21256)
  * Added the `--title` command line argument to set the process title on
    startup. (https://github.com/nodejs/node/pull/21477)
* trace_events:
  * Added process_name metadata.
    (https://github.com/nodejs/node/pull/21477)
* Added new collaborators
  * codebytere - Shelley Vohr

PR-URL: https://github.com/nodejs/node/pull/21851
---
 CHANGELOG.md                    |   3 +-
 doc/api/cli.md                  |   2 +-
 doc/api/console.md              |   2 +-
 doc/api/n-api.md                |  12 +--
 doc/api/process.md              |   2 +-
 doc/changelogs/CHANGELOG_V10.md | 145 ++++++++++++++++++++++++++++++++
 src/node_version.h              |   6 +-
 7 files changed, 159 insertions(+), 13 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index af54237dfa74d1..b93976dde5d728 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,7 +31,8 @@ release.
 </tr>
 <tr>
     <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V10.md#10.6.0">10.6.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V10.md#10.7.0">10.7.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V10.md#10.6.0">10.6.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.5.0">10.5.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.4.1">10.4.1</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.4.0">10.4.0</a><br/>
diff --git a/doc/api/cli.md b/doc/api/cli.md
index 7ebfb084d76abb..4986d019129b4e 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -280,7 +280,7 @@ Throw errors for deprecations.
 
 ### `--title=title`
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 Set `process.title` on startup.
diff --git a/doc/api/console.md b/doc/api/console.md
index 95801c31fed63c..efc06eacd313b6 100644
--- a/doc/api/console.md
+++ b/doc/api/console.md
@@ -415,7 +415,7 @@ console.timeEnd('100-elements');
 
 ### console.timeLog([label][, ...data])
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 * `label` {string} **Default:** `'default'`
 * `...data` {any}
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 5fbe4bb07469c2..44223e19026c52 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1695,7 +1695,7 @@ The JavaScript `Number` type is described in
 
 #### napi_create_bigint_int64
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
@@ -1716,7 +1716,7 @@ This API converts the C `int64_t` type to the JavaScript `BigInt` type.
 
 #### napi_create_bigint_uint64
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
@@ -1737,7 +1737,7 @@ This API converts the C `uint64_t` type to the JavaScript `BigInt` type.
 
 #### napi_create_bigint_words
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
@@ -2051,7 +2051,7 @@ This API returns the C double primitive equivalent of the given JavaScript
 
 #### napi_get_value_bigint_int64
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
@@ -2079,7 +2079,7 @@ This API returns the C `int64_t` primitive equivalent of the given JavaScript
 
 #### napi_get_value_bigint_uint64
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
@@ -2107,7 +2107,7 @@ This API returns the C `uint64_t` primitive equivalent of the given JavaScript
 
 #### napi_get_value_bigint_words
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 > Stability: 1 - Experimental
diff --git a/doc/api/process.md b/doc/api/process.md
index 2c27409d809080..dd0314cf6c3c1d 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1196,7 +1196,7 @@ setTimeout(() => {
 
 ## process.hrtime.bigint()
 <!-- YAML
-added: REPLACEME
+added: v10.7.0
 -->
 
 * Returns: {bigint}
diff --git a/doc/changelogs/CHANGELOG_V10.md b/doc/changelogs/CHANGELOG_V10.md
index 1973dfd3f3ee97..bf90f2a09d8e40 100644
--- a/doc/changelogs/CHANGELOG_V10.md
+++ b/doc/changelogs/CHANGELOG_V10.md
@@ -9,6 +9,7 @@
 </tr>
 <tr>
 <td>
+<a href="#10.7.0">10.7.0</a><br/>
 <a href="#10.6.0">10.6.0</a><br/>
 <a href="#10.5.0">10.5.0</a><br/>
 <a href="#10.4.1">10.4.1</a><br/>
@@ -34,6 +35,150 @@
   * [io.js](CHANGELOG_IOJS.md)
   * [Archive](CHANGELOG_ARCHIVE.md)
 
+<a id="10.7.0"></a>
+## 2018-07-18, Version 10.7.0 (Current), @targos
+
+### Notable Changes
+
+* **console**:
+  * The `console.timeLog()` method has been implemented. [#21312](https://github.com/nodejs/node/pull/21312)
+* **deps**:
+  * Upgrade to libuv 1.22.0. [#21731](https://github.com/nodejs/node/pull/21731)
+  * Upgrade to ICU 62.1 (Unicode 11, CLDR 33.1). [#21728](https://github.com/nodejs/node/pull/21728)
+* **http**:
+  * Added support for passing both `timeout` and `agent` options to
+    `http.request`. [#21204](https://github.com/nodejs/node/pull/21204)
+* **inspector**:
+  * Expose the original console API in `require('inspector').console`. [#21659](https://github.com/nodejs/node/pull/21659)
+* **napi**:
+  * Added experimental support for functions dealing with bigint numbers. [#21226](https://github.com/nodejs/node/pull/21226)
+* **process**:
+  * The `process.hrtime.bigint()` method has been implemented. [#21256](https://github.com/nodejs/node/pull/21256)
+  * Added the `--title` command line argument to set the process title on
+    startup. [#21477](https://github.com/nodejs/node/pull/21477)
+* **trace_events**:
+  * Added process\_name metadata. [#21477](https://github.com/nodejs/node/pull/21477)
+* **Added new collaborators**
+  * [codebytere](https://github.com/codebytere) - Shelley Vohr
+
+### Commits
+
+* [[`8c97ffb2f5`](https://github.com/nodejs/node/commit/8c97ffb2f5)] - **assert**: improve simple assert (Ruben Bridgewater) [#21626](https://github.com/nodejs/node/pull/21626)
+* [[`9776f1cbef`](https://github.com/nodejs/node/commit/9776f1cbef)] - **benchmark**: add n-api function args benchmark (Kenny Yuan) [#21555](https://github.com/nodejs/node/pull/21555)
+* [[`576f1ea978`](https://github.com/nodejs/node/commit/576f1ea978)] - **buffer**: remove superfluous assignment (Tobias Nießen) [#21844](https://github.com/nodejs/node/pull/21844)
+* [[`6bb2b5a51d`](https://github.com/nodejs/node/commit/6bb2b5a51d)] - **build**: account for pure C sources in `build-addons-napi` (Anna Henningsen) [#21797](https://github.com/nodejs/node/pull/21797)
+* [[`c02fb88936`](https://github.com/nodejs/node/commit/c02fb88936)] - **build**: enabling lto at configure (Octavian Soldea) [#21677](https://github.com/nodejs/node/pull/21677)
+* [[`2a0862cec9`](https://github.com/nodejs/node/commit/2a0862cec9)] - **console**: fix timeEnd() not coercing the input (Ruben Bridgewater) [#21779](https://github.com/nodejs/node/pull/21779)
+* [[`f3c397cd21`](https://github.com/nodejs/node/commit/f3c397cd21)] - **(SEMVER-MINOR)** **console**: implement timeLog method (Michaël Zasso) [#21312](https://github.com/nodejs/node/pull/21312)
+* [[`73cafd853c`](https://github.com/nodejs/node/commit/73cafd853c)] - **console,util**: avoid pair array generation in C++ (Anna Henningsen) [#20831](https://github.com/nodejs/node/pull/20831)
+* [[`d9825c7a16`](https://github.com/nodejs/node/commit/d9825c7a16)] - **crypto**: prevent Sign::SignFinal from crashing (Tobias Nießen) [#21815](https://github.com/nodejs/node/pull/21815)
+* [[`07cce880bf`](https://github.com/nodejs/node/commit/07cce880bf)] - **crypto**: handle OpenSSL error queue in CipherBase (Tobias Nießen) [#21288](https://github.com/nodejs/node/pull/21288)
+* [[`355c5e3c95`](https://github.com/nodejs/node/commit/355c5e3c95)] - **deps**: cherry-pick 555c811 from upstream V8 (Anna Henningsen) [#21741](https://github.com/nodejs/node/pull/21741)
+* [[`42d75392c5`](https://github.com/nodejs/node/commit/42d75392c5)] - **deps**: patch V8 to 6.7.288.49 (Myles Borins) [#21727](https://github.com/nodejs/node/pull/21727)
+* [[`6920091488`](https://github.com/nodejs/node/commit/6920091488)] - **deps**: upgrade to libuv 1.22.0 (cjihrig) [#21731](https://github.com/nodejs/node/pull/21731)
+* [[`122ae24f62`](https://github.com/nodejs/node/commit/122ae24f62)] - **deps**: icu 62.1 bump (Unicode 11, CLDR 33.1) (Steven R. Loomis) [#21728](https://github.com/nodejs/node/pull/21728)
+* [[`a5233c7e17`](https://github.com/nodejs/node/commit/a5233c7e17)] - **deps**: cherry-pick 477df06 from upstream v8 (Gus Caplan) [#21644](https://github.com/nodejs/node/pull/21644)
+* [[`506631a9f9`](https://github.com/nodejs/node/commit/506631a9f9)] - **doc**: fix structure and formatting in inspector.md (Vse Mozhet Byt) [#21709](https://github.com/nodejs/node/pull/21709)
+* [[`53b587a5af`](https://github.com/nodejs/node/commit/53b587a5af)] - **doc**: add documentation for buffer.byteOffset (Andreas Madsen) [#21718](https://github.com/nodejs/node/pull/21718)
+* [[`51dfebf9ac`](https://github.com/nodejs/node/commit/51dfebf9ac)] - **doc**: fix vm.runInNewContext signature (Michaël Zasso) [#21824](https://github.com/nodejs/node/pull/21824)
+* [[`10f9374ea3`](https://github.com/nodejs/node/commit/10f9374ea3)] - **doc**: make markdown input compliant (Sam Ruby) [#21780](https://github.com/nodejs/node/pull/21780)
+* [[`02982998db`](https://github.com/nodejs/node/commit/02982998db)] - **doc**: add my pronoun (Ruben Bridgewater) [#21813](https://github.com/nodejs/node/pull/21813)
+* [[`ca8c96035a`](https://github.com/nodejs/node/commit/ca8c96035a)] - **doc**: update readme with my pronouns (Lance Ball) [#21818](https://github.com/nodejs/node/pull/21818)
+* [[`d33281b36f`](https://github.com/nodejs/node/commit/d33281b36f)] - **doc**: prevent some redirections (Vse Mozhet Byt) [#21811](https://github.com/nodejs/node/pull/21811)
+* [[`0de0f89d0c`](https://github.com/nodejs/node/commit/0de0f89d0c)] - **doc**: add "Edit on GitHub" link (Rich Trott) [#21703](https://github.com/nodejs/node/pull/21703)
+* [[`7ab6efdb94`](https://github.com/nodejs/node/commit/7ab6efdb94)] - **doc**: add policy for landing new npm releases (Myles Borins) [#21594](https://github.com/nodejs/node/pull/21594)
+* [[`3d93273bf7`](https://github.com/nodejs/node/commit/3d93273bf7)] - **doc**: add OS X to instead of only macOS (XadillaX) [#21033](https://github.com/nodejs/node/pull/21033)
+* [[`577d24baa4`](https://github.com/nodejs/node/commit/577d24baa4)] - **doc**: fix module.children description (Travis Fischer) [#21672](https://github.com/nodejs/node/pull/21672)
+* [[`cd6601b87a`](https://github.com/nodejs/node/commit/cd6601b87a)] - **doc**: fix HTTP res 'finish' description (Sergey Zelenov) [#21670](https://github.com/nodejs/node/pull/21670)
+* [[`51db88b0f1`](https://github.com/nodejs/node/commit/51db88b0f1)] - **doc**: fix http2stream.pushStream error doc (Сковорода Никита Андреевич) [#21487](https://github.com/nodejs/node/pull/21487)
+* [[`6e1917a596`](https://github.com/nodejs/node/commit/6e1917a596)] - **doc**: update changelog with 9.x EOL (Сковорода Никита Андреевич) [#21612](https://github.com/nodejs/node/pull/21612)
+* [[`cd77d8782a`](https://github.com/nodejs/node/commit/cd77d8782a)] - **doc**: improve documentation of fs sync methods (iwko) [#21243](https://github.com/nodejs/node/pull/21243)
+* [[`1044bafec4`](https://github.com/nodejs/node/commit/1044bafec4)] - **doc**: remove \_Node.js style callback\_ (Rich Trott) [#21701](https://github.com/nodejs/node/pull/21701)
+* [[`971679328e`](https://github.com/nodejs/node/commit/971679328e)] - **doc**: add codebytere as collaborator (Shelley Vohr) [#21700](https://github.com/nodejs/node/pull/21700)
+* [[`034fe19862`](https://github.com/nodejs/node/commit/034fe19862)] - **doc**: add links to inline HTML table (Rich Trott) [#21678](https://github.com/nodejs/node/pull/21678)
+* [[`04eed2342d`](https://github.com/nodejs/node/commit/04eed2342d)] - **doc**: remove "note that" from fs doc (Rich Trott) [#21646](https://github.com/nodejs/node/pull/21646)
+* [[`c8d5bab022`](https://github.com/nodejs/node/commit/c8d5bab022)] - **doc**: fix doc for napi\_create\_function (Gabriel Schulhof)
+* [[`f7aa22a0eb`](https://github.com/nodejs/node/commit/f7aa22a0eb)] - **doc**: improve guide text for CI runs (Rich Trott) [#21645](https://github.com/nodejs/node/pull/21645)
+* [[`6f8ebc08b9`](https://github.com/nodejs/node/commit/6f8ebc08b9)] - **doc**: unify spelling of backpressure (Thomas Watson) [#21630](https://github.com/nodejs/node/pull/21630)
+* [[`3fffc7e95f`](https://github.com/nodejs/node/commit/3fffc7e95f)] - **errors**: fix undefined HTTP2 and tls errors (Shailesh Shekhawat) [#21564](https://github.com/nodejs/node/pull/21564)
+* [[`b758006c23`](https://github.com/nodejs/node/commit/b758006c23)] - **fs**: fix fsPromises.lchmod error on non-Mac (Masashi Hirano) [#21435](https://github.com/nodejs/node/pull/21435)
+* [[`4fa7150962`](https://github.com/nodejs/node/commit/4fa7150962)] - **fs**: support pseudofiles in promises.readFile (Timothy Gu) [#21497](https://github.com/nodejs/node/pull/21497)
+* [[`bba500d0ea`](https://github.com/nodejs/node/commit/bba500d0ea)] - **(SEMVER-MINOR)** **http**: fix request with option timeout and agent (killagu) [#21204](https://github.com/nodejs/node/pull/21204)
+* [[`0b3c80ca31`](https://github.com/nodejs/node/commit/0b3c80ca31)] - **http2**: fix issues with aborted `respondWithFile()`s (Anna Henningsen) [#21561](https://github.com/nodejs/node/pull/21561)
+* [[`238ef58841`](https://github.com/nodejs/node/commit/238ef58841)] - **http2**: remove `waitTrailers` listener after closing a stream (RidgeA) [#21764](https://github.com/nodejs/node/pull/21764)
+* [[`07160cd2fd`](https://github.com/nodejs/node/commit/07160cd2fd)] - **http2**: order declarations in core.js (Rich Trott) [#21689](https://github.com/nodejs/node/pull/21689)
+* [[`c88af232c8`](https://github.com/nodejs/node/commit/c88af232c8)] - **http2**: pass incoming set-cookie header as array (Gerhard Stoebich) [#21360](https://github.com/nodejs/node/pull/21360)
+* [[`2922028362`](https://github.com/nodejs/node/commit/2922028362)] - **(SEMVER-MINOR)** **inspector**: expose original console (Matteo Collina) [#21659](https://github.com/nodejs/node/pull/21659)
+* [[`b2291296ef`](https://github.com/nodejs/node/commit/b2291296ef)] - **inspector**: split main thread interface from transport (Eugene Ostroukhov) [#21182](https://github.com/nodejs/node/pull/21182)
+* [[`4ed4bf3bdd`](https://github.com/nodejs/node/commit/4ed4bf3bdd)] - **lib**: update punycode to 2.1.1 (Rich Trott) [#21768](https://github.com/nodejs/node/pull/21768)
+* [[`4433ecbf30`](https://github.com/nodejs/node/commit/4433ecbf30)] - **lib**: refactor cli table (Ruben Bridgewater) [#20960](https://github.com/nodejs/node/pull/20960)
+* [[`92d79212ec`](https://github.com/nodejs/node/commit/92d79212ec)] - **lib**: consolidate redundant require() calls (cjihrig) [#21699](https://github.com/nodejs/node/pull/21699)
+* [[`ed774b7930`](https://github.com/nodejs/node/commit/ed774b7930)] - **messaging**: fix edge cases with transferring ports (Timothy Gu) [#21540](https://github.com/nodejs/node/pull/21540)
+* [[`221c8bd58f`](https://github.com/nodejs/node/commit/221c8bd58f)] - **messaging**: use actual DOMException for DataCloneError (Timothy Gu) [#21540](https://github.com/nodejs/node/pull/21540)
+* [[`4f3bbfaaca`](https://github.com/nodejs/node/commit/4f3bbfaaca)] - **n-api**: test uint32 truncation (Gabriel Schulhof) [#21722](https://github.com/nodejs/node/pull/21722)
+* [[`b8ba003fbf`](https://github.com/nodejs/node/commit/b8ba003fbf)] - **n-api**: remove experimental gate from status codes (Gabriel Schulhof) [#21680](https://github.com/nodejs/node/pull/21680)
+* [[`109c59971a`](https://github.com/nodejs/node/commit/109c59971a)] - **n-api**: create functions directly (Gabriel Schulhof) [#21688](https://github.com/nodejs/node/pull/21688)
+* [[`cec166e85f`](https://github.com/nodejs/node/commit/cec166e85f)] - **n-api**: restrict exports by version (Kyle Farnung) [#19962](https://github.com/nodejs/node/pull/19962)
+* [[`3096ee5a4b`](https://github.com/nodejs/node/commit/3096ee5a4b)] - **(SEMVER-MINOR)** **napi**: add bigint support (Gus Caplan) [#21226](https://github.com/nodejs/node/pull/21226)
+* [[`581390c59d`](https://github.com/nodejs/node/commit/581390c59d)] - **process**: split bootstrappers by threads that can run them (Joyee Cheung) [#21378](https://github.com/nodejs/node/pull/21378)
+* [[`f1b18ba412`](https://github.com/nodejs/node/commit/f1b18ba412)] - **(SEMVER-MINOR)** **process**: implement process.hrtime.bigint() (Joyee Cheung) [#21256](https://github.com/nodejs/node/pull/21256)
+* [[`961f6e8623`](https://github.com/nodejs/node/commit/961f6e8623)] - **process**: fix process.exitCode handling for fatalException (Denys Otrishko) [#21739](https://github.com/nodejs/node/pull/21739)
+* [[`4b613d3976`](https://github.com/nodejs/node/commit/4b613d3976)] - **repl**: make own properties shadow prototype properties (Sam Ruby) [#21588](https://github.com/nodejs/node/pull/21588)
+* [[`1019c2d317`](https://github.com/nodejs/node/commit/1019c2d317)] - **src**: fix async hooks crashing when there is no node context (Javier Gonzalez) [#19134](https://github.com/nodejs/node/pull/19134)
+* [[`a9a718696e`](https://github.com/nodejs/node/commit/a9a718696e)] - **src**: make heap snapshot & embedder graph accessible for tests (Anna Henningsen) [#21741](https://github.com/nodejs/node/pull/21741)
+* [[`5121278f5c`](https://github.com/nodejs/node/commit/5121278f5c)] - **src**: use V8 graph heap snapshot API (Anna Henningsen) [#21741](https://github.com/nodejs/node/pull/21741)
+* [[`d42dbde1a8`](https://github.com/nodejs/node/commit/d42dbde1a8)] - **src**: add iteration over all base objects to Environment (Anna Henningsen) [#21741](https://github.com/nodejs/node/pull/21741)
+* [[`4ed5d1a623`](https://github.com/nodejs/node/commit/4ed5d1a623)] - **src**: add HandleWrap::AddWrapMethods (Jon Moss) [#21769](https://github.com/nodejs/node/pull/21769)
+* [[`51d613db2d`](https://github.com/nodejs/node/commit/51d613db2d)] - **src**: start annotating native code side effect (Timothy Gu) [#21458](https://github.com/nodejs/node/pull/21458)
+* [[`466601f47f`](https://github.com/nodejs/node/commit/466601f47f)] - **src**: remove .h if -inl.h is already included (Daniel Bevenius) [#21381](https://github.com/nodejs/node/pull/21381)
+* [[`a68b7dda5f`](https://github.com/nodejs/node/commit/a68b7dda5f)] - **src**: add node\_process.cc (James M Snell) [#21105](https://github.com/nodejs/node/pull/21105)
+* [[`cb698111c4`](https://github.com/nodejs/node/commit/cb698111c4)] - **src**: add comment on CallbackScope exception behaviour (Anna Henningsen) [#21743](https://github.com/nodejs/node/pull/21743)
+* [[`712809eb1b`](https://github.com/nodejs/node/commit/712809eb1b)] - **src**: enable more detailed memory tracking (Anna Henningsen) [#21742](https://github.com/nodejs/node/pull/21742)
+* [[`277077853f`](https://github.com/nodejs/node/commit/277077853f)] - **src**: make Environment::is\_stopping\_worker inline (Jon Moss) [#21720](https://github.com/nodejs/node/pull/21720)
+* [[`d06305635d`](https://github.com/nodejs/node/commit/d06305635d)] - **(SEMVER-MINOR)** **src**: add --title command line argument (James M Snell) [#21477](https://github.com/nodejs/node/pull/21477)
+* [[`ceec23e6e4`](https://github.com/nodejs/node/commit/ceec23e6e4)] - **src**: remove using directives from spawn\_sync.h (Daniel Bevenius) [#21634](https://github.com/nodejs/node/pull/21634)
+* [[`3a627c830b`](https://github.com/nodejs/node/commit/3a627c830b)] - **src**: add context-aware init macro and doc (Gabriel Schulhof) [#21318](https://github.com/nodejs/node/pull/21318)
+* [[`aa5994f2b9`](https://github.com/nodejs/node/commit/aa5994f2b9)] - **src,tools**: use https://nodejs.org URL when possible. (XhmikosR) [#21719](https://github.com/nodejs/node/pull/21719)
+* [[`0108ff6b51`](https://github.com/nodejs/node/commit/0108ff6b51)] - **test**: add support for NODE\_TEST\_DIR on a separate mount point (Antoine du HAMEL) [#21552](https://github.com/nodejs/node/pull/21552)
+* [[`eef975ebae`](https://github.com/nodejs/node/commit/eef975ebae)] - **test**: move inspector test back to parallel, unmark flaky (Anna Henningsen) [#21806](https://github.com/nodejs/node/pull/21806)
+* [[`67908e9933`](https://github.com/nodejs/node/commit/67908e9933)] - **test**: fix build warnings in bigint N-API test (Anna Henningsen) [#21796](https://github.com/nodejs/node/pull/21796)
+* [[`6b72583bf8`](https://github.com/nodejs/node/commit/6b72583bf8)] - **test**: refactor test-tls-connect-memleak, move to parallel (Anna Henningsen) [#21794](https://github.com/nodejs/node/pull/21794)
+* [[`174a9db51a`](https://github.com/nodejs/node/commit/174a9db51a)] - **test**: refactor test-net-connect-memleak, move to parallel (Anna Henningsen) [#21794](https://github.com/nodejs/node/pull/21794)
+* [[`b338ff54bb`](https://github.com/nodejs/node/commit/b338ff54bb)] - **test**: add gc tracking to common API (Anna Henningsen) [#21794](https://github.com/nodejs/node/pull/21794)
+* [[`4e60ce8f87`](https://github.com/nodejs/node/commit/4e60ce8f87)] - **test**: fix flaky test-debug-prompt (Rich Trott) [#21826](https://github.com/nodejs/node/pull/21826)
+* [[`a2edb59870`](https://github.com/nodejs/node/commit/a2edb59870)] - **test**: fix comment of fs.promises write (Ryuichi Sakagami) [#21708](https://github.com/nodejs/node/pull/21708)
+* [[`32ad163038`](https://github.com/nodejs/node/commit/32ad163038)] - **test**: add test of fs.promises write for non-string buffers (Ryuichi Sakagami) [#21708](https://github.com/nodejs/node/pull/21708)
+* [[`7352b72fc9`](https://github.com/nodejs/node/commit/7352b72fc9)] - **test**: add heap snapshot tests (Anna Henningsen) [#21741](https://github.com/nodejs/node/pull/21741)
+* [[`678313d18b`](https://github.com/nodejs/node/commit/678313d18b)] - **test**: add filehandle sync() and datasync() tests (Masashi Hirano) [#20530](https://github.com/nodejs/node/pull/20530)
+* [[`a09bdb5847`](https://github.com/nodejs/node/commit/a09bdb5847)] - **test**: improve console table error output (Ruben Bridgewater) [#20960](https://github.com/nodejs/node/pull/20960)
+* [[`600349aaba`](https://github.com/nodejs/node/commit/600349aaba)] - **test**: refactor process/worker exitCode tests (Denys Otrishko) [#21739](https://github.com/nodejs/node/pull/21739)
+* [[`15026511b8`](https://github.com/nodejs/node/commit/15026511b8)] - **test**: remove timer in fs.watchFile() test (Rich Trott) [#21694](https://github.com/nodejs/node/pull/21694)
+* [[`ae5d5658b9`](https://github.com/nodejs/node/commit/ae5d5658b9)] - **test**: fix flaky watchFile() (Rich Trott) [#21694](https://github.com/nodejs/node/pull/21694)
+* [[`ada3f34cd4`](https://github.com/nodejs/node/commit/ada3f34cd4)] - **test**: fix weird string error (Jon Moss) [#21793](https://github.com/nodejs/node/pull/21793)
+* [[`f46536be23`](https://github.com/nodejs/node/commit/f46536be23)] - **test**: fix timeouts when running worker tests with `--worker` (Anna Henningsen) [#21791](https://github.com/nodejs/node/pull/21791)
+* [[`f386c0a517`](https://github.com/nodejs/node/commit/f386c0a517)] - **test**: add test for dns.promises.resolve . (Keita Akutsu) [#21691](https://github.com/nodejs/node/pull/21691)
+* [[`11e9b4ecee`](https://github.com/nodejs/node/commit/11e9b4ecee)] - **test**: fix parallel/test-tls-env-extra-ca.js (Niicck) [#21647](https://github.com/nodejs/node/pull/21647)
+* [[`eda7fffba4`](https://github.com/nodejs/node/commit/eda7fffba4)] - **test**: swap arguments in strictEqual() (Sohail Rajdev) [#21660](https://github.com/nodejs/node/pull/21660)
+* [[`194d1955a7`](https://github.com/nodejs/node/commit/194d1955a7)] - **test**: fix test-tls-connect-memleak (Rich Trott) [#21681](https://github.com/nodejs/node/pull/21681)
+* [[`24f649c8cf`](https://github.com/nodejs/node/commit/24f649c8cf)] - **test**: fix pummel/test-net-connect-memleak (Rich Trott) [#21658](https://github.com/nodejs/node/pull/21658)
+* [[`021dd5404c`](https://github.com/nodejs/node/commit/021dd5404c)] - **test**: remove unnecessary string literals (Jacek Pospychała) [#21638](https://github.com/nodejs/node/pull/21638)
+* [[`47b10e30c0`](https://github.com/nodejs/node/commit/47b10e30c0)] - **test**: replace third argument with comment in strict equals (Developer Davo) [#21603](https://github.com/nodejs/node/pull/21603)
+* [[`25dac95164`](https://github.com/nodejs/node/commit/25dac95164)] - **test**: fix args passed to strictEqual (Haroon Khan) [#21584](https://github.com/nodejs/node/pull/21584)
+* [[`fe9888a34a`](https://github.com/nodejs/node/commit/fe9888a34a)] - **test**: check type for Worker filename argument (Masashi Hirano) [#21620](https://github.com/nodejs/node/pull/21620)
+* [[`9cd5c0ec79`](https://github.com/nodejs/node/commit/9cd5c0ec79)] - **test**: add test for missing dynamic instantiate hook (Michaël Zasso) [#21506](https://github.com/nodejs/node/pull/21506)
+* [[`dc84858787`](https://github.com/nodejs/node/commit/dc84858787)] - **test,util**: add missing tests and conditions (MaleDong) [#21455](https://github.com/nodejs/node/pull/21455)
+* [[`c26ba082ae`](https://github.com/nodejs/node/commit/c26ba082ae)] - **tools**: avoid global install of dmn for lint update (Rich Trott) [#21744](https://github.com/nodejs/node/pull/21744)
+* [[`e030dd7d65`](https://github.com/nodejs/node/commit/e030dd7d65)] - **tools**: add no-duplicate-requires rule (Gus Caplan) [#21712](https://github.com/nodejs/node/pull/21712)
+* [[`b9bbbbe5d1`](https://github.com/nodejs/node/commit/b9bbbbe5d1)] - **tools**: build all.json by combining generated JSON (Sam Ruby) [#21637](https://github.com/nodejs/node/pull/21637)
+* [[`214c608208`](https://github.com/nodejs/node/commit/214c608208)] - **tools**: lint doc code examples in strict mode (Vse Mozhet Byt) [#21615](https://github.com/nodejs/node/pull/21615)
+* [[`27d17d4600`](https://github.com/nodejs/node/commit/27d17d4600)] - **trace_events**: add traced\_value.cc/traced\_value.h (James M Snell) [#21475](https://github.com/nodejs/node/pull/21475)
+* [[`c4d7413a15`](https://github.com/nodejs/node/commit/c4d7413a15)] - **(SEMVER-MINOR)** **trace_events**: add process\_name metadata (James M Snell) [#21477](https://github.com/nodejs/node/pull/21477)
+* [[`b0943a655e`](https://github.com/nodejs/node/commit/b0943a655e)] - **worker**: exit after uncaught exception (Denys Otrishko) [#21739](https://github.com/nodejs/node/pull/21739)
+* [[`25fef3d8d4`](https://github.com/nodejs/node/commit/25fef3d8d4)] - **workers**: fix invalid exit code in parent upon uncaught exception (Denys Otrishko) [#21713](https://github.com/nodejs/node/pull/21713)
+* [[`48b16aad47`](https://github.com/nodejs/node/commit/48b16aad47)] - **zlib**: instance-ify two methods (Jon Moss) [#21702](https://github.com/nodejs/node/pull/21702)
+* [[`dae7130929`](https://github.com/nodejs/node/commit/dae7130929)] - **zlib**: track memory allocated by zlib (Anna Henningsen) [#21608](https://github.com/nodejs/node/pull/21608)
+* [[`96dae83713`](https://github.com/nodejs/node/commit/96dae83713)] - **zlib**: fix memory leak for unused zlib instances (Anna Henningsen) [#21607](https://github.com/nodejs/node/pull/21607)
+
 <a id="10.6.0"></a>
 ## 2018-07-04, Version 10.6.0 (Current), @targos
 
diff --git a/src/node_version.h b/src/node_version.h
index 0a7d134d9e25e4..8370b4c86f44db 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -23,13 +23,13 @@
 #define SRC_NODE_VERSION_H_
 
 #define NODE_MAJOR_VERSION 10
-#define NODE_MINOR_VERSION 6
-#define NODE_PATCH_VERSION 1
+#define NODE_MINOR_VERSION 7
+#define NODE_PATCH_VERSION 0
 
 #define NODE_VERSION_IS_LTS 0
 #define NODE_VERSION_LTS_CODENAME ""
 
-#define NODE_VERSION_IS_RELEASE 0
+#define NODE_VERSION_IS_RELEASE 1
 
 #ifndef NODE_STRINGIFY
 #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)