jsqr.js

(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === "object" && typeof module === "object")
      module.exports = factory();
    else if (typeof define === "function" && define.amd) define([], factory);
    else if (typeof exports === "object") exports["jsQR"] = factory();
    else root["jsQR"] = factory();
  })(typeof self !== "undefined" ? self : this, function () {
    return /******/ (function (modules) {
      // webpackBootstrap
      /******/ // The module cache
      /******/ var installedModules = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/
        /******/ // Check if module is in cache
        /******/ if (installedModules[moduleId]) {
          /******/ return installedModules[moduleId].exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (installedModules[moduleId] = {
          /******/ i: moduleId,
          /******/ l: false,
          /******/ exports: {},
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ modules[moduleId].call(
          module.exports,
          module,
          module.exports,
          __webpack_require__
        ); // Flag the module as loaded
        /******/
        /******/ /******/ module.l = true; // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } // expose the modules object (__webpack_modules__)
      /******/
      /******/
      /******/ /******/ __webpack_require__.m = modules; // expose the module cache
      /******/
      /******/ /******/ __webpack_require__.c = installedModules; // define getter function for harmony exports
      /******/
      /******/ /******/ __webpack_require__.d = function (exports, name, getter) {
        /******/ if (!__webpack_require__.o(exports, name)) {
          /******/ Object.defineProperty(exports, name, {
            /******/ configurable: false,
            /******/ enumerable: true,
            /******/ get: getter,
            /******/
          });
          /******/
        }
        /******/
      }; // getDefaultExport function for compatibility with non-harmony modules
      /******/
      /******/ /******/ __webpack_require__.n = function (module) {
        /******/ var getter =
          module && module.__esModule
            ? /******/ function getDefault() {
                return module["default"];
              }
            : /******/ function getModuleExports() {
                return module;
              };
        /******/ __webpack_require__.d(getter, "a", getter);
        /******/ return getter;
        /******/
      }; // Object.prototype.hasOwnProperty.call
      /******/
      /******/ /******/ __webpack_require__.o = function (object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      }; // __webpack_public_path__
      /******/
      /******/ /******/ __webpack_require__.p = ""; // Load entry module and return exports
      /******/
      /******/ /******/ return __webpack_require__((__webpack_require__.s = 3));
      /******/
    })(
      /************************************************************************/
      /******/ [
        /* 0 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var BitMatrix = /** @class */ (function () {
            function BitMatrix(data, width) {
              this.width = width;
              this.height = data.length / width;
              this.data = data;
            }
            BitMatrix.createEmpty = function (width, height) {
              return new BitMatrix(new Uint8ClampedArray(width * height), width);
            };
            BitMatrix.prototype.get = function (x, y) {
              if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
                return false;
              }
              return !!this.data[y * this.width + x];
            };
            BitMatrix.prototype.set = function (x, y, v) {
              this.data[y * this.width + x] = v ? 1 : 0;
            };
            BitMatrix.prototype.setRegion = function (
              left,
              top,
              width,
              height,
              v
            ) {
              for (var y = top; y < top + height; y++) {
                for (var x = left; x < left + width; x++) {
                  this.set(x, y, !!v);
                }
              }
            };
            return BitMatrix;
          })();
          exports.BitMatrix = BitMatrix;
  
          /***/
        },
        /* 1 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var GenericGFPoly_1 = __webpack_require__(2);
          function addOrSubtractGF(a, b) {
            return a ^ b; // tslint:disable-line:no-bitwise
          }
          exports.addOrSubtractGF = addOrSubtractGF;
          var GenericGF = /** @class */ (function () {
            function GenericGF(primitive, size, genBase) {
              this.primitive = primitive;
              this.size = size;
              this.generatorBase = genBase;
              this.expTable = new Array(this.size);
              this.logTable = new Array(this.size);
              var x = 1;
              for (var i = 0; i < this.size; i++) {
                this.expTable[i] = x;
                x = x * 2;
                if (x >= this.size) {
                  x = (x ^ this.primitive) & (this.size - 1); // tslint:disable-line:no-bitwise
                }
              }
              for (var i = 0; i < this.size - 1; i++) {
                this.logTable[this.expTable[i]] = i;
              }
              this.zero = new GenericGFPoly_1.default(
                this,
                Uint8ClampedArray.from([0])
              );
              this.one = new GenericGFPoly_1.default(
                this,
                Uint8ClampedArray.from([1])
              );
            }
            GenericGF.prototype.multiply = function (a, b) {
              if (a === 0 || b === 0) {
                return 0;
              }
              return this.expTable[
                (this.logTable[a] + this.logTable[b]) % (this.size - 1)
              ];
            };
            GenericGF.prototype.inverse = function (a) {
              if (a === 0) {
                throw new Error("Can't invert 0");
              }
              return this.expTable[this.size - this.logTable[a] - 1];
            };
            GenericGF.prototype.buildMonomial = function (degree, coefficient) {
              if (degree < 0) {
                throw new Error("Invalid monomial degree less than 0");
              }
              if (coefficient === 0) {
                return this.zero;
              }
              var coefficients = new Uint8ClampedArray(degree + 1);
              coefficients[0] = coefficient;
              return new GenericGFPoly_1.default(this, coefficients);
            };
            GenericGF.prototype.log = function (a) {
              if (a === 0) {
                throw new Error("Can't take log(0)");
              }
              return this.logTable[a];
            };
            GenericGF.prototype.exp = function (a) {
              return this.expTable[a];
            };
            return GenericGF;
          })();
          exports.default = GenericGF;
  
          /***/
        },
        /* 2 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var GenericGF_1 = __webpack_require__(1);
          var GenericGFPoly = /** @class */ (function () {
            function GenericGFPoly(field, coefficients) {
              if (coefficients.length === 0) {
                throw new Error("No coefficients.");
              }
              this.field = field;
              var coefficientsLength = coefficients.length;
              if (coefficientsLength > 1 && coefficients[0] === 0) {
                // Leading term must be non-zero for anything except the constant polynomial "0"
                var firstNonZero = 1;
                while (
                  firstNonZero < coefficientsLength &&
                  coefficients[firstNonZero] === 0
                ) {
                  firstNonZero++;
                }
                if (firstNonZero === coefficientsLength) {
                  this.coefficients = field.zero.coefficients;
                } else {
                  this.coefficients = new Uint8ClampedArray(
                    coefficientsLength - firstNonZero
                  );
                  for (var i = 0; i < this.coefficients.length; i++) {
                    this.coefficients[i] = coefficients[firstNonZero + i];
                  }
                }
              } else {
                this.coefficients = coefficients;
              }
            }
            GenericGFPoly.prototype.degree = function () {
              return this.coefficients.length - 1;
            };
            GenericGFPoly.prototype.isZero = function () {
              return this.coefficients[0] === 0;
            };
            GenericGFPoly.prototype.getCoefficient = function (degree) {
              return this.coefficients[this.coefficients.length - 1 - degree];
            };
            GenericGFPoly.prototype.addOrSubtract = function (other) {
              var _a;
              if (this.isZero()) {
                return other;
              }
              if (other.isZero()) {
                return this;
              }
              var smallerCoefficients = this.coefficients;
              var largerCoefficients = other.coefficients;
              if (smallerCoefficients.length > largerCoefficients.length) {
                (_a = [largerCoefficients, smallerCoefficients]),
                  (smallerCoefficients = _a[0]),
                  (largerCoefficients = _a[1]);
              }
              var sumDiff = new Uint8ClampedArray(largerCoefficients.length);
              var lengthDiff =
                largerCoefficients.length - smallerCoefficients.length;
              for (var i = 0; i < lengthDiff; i++) {
                sumDiff[i] = largerCoefficients[i];
              }
              for (var i = lengthDiff; i < largerCoefficients.length; i++) {
                sumDiff[i] = GenericGF_1.addOrSubtractGF(
                  smallerCoefficients[i - lengthDiff],
                  largerCoefficients[i]
                );
              }
              return new GenericGFPoly(this.field, sumDiff);
            };
            GenericGFPoly.prototype.multiply = function (scalar) {
              if (scalar === 0) {
                return this.field.zero;
              }
              if (scalar === 1) {
                return this;
              }
              var size = this.coefficients.length;
              var product = new Uint8ClampedArray(size);
              for (var i = 0; i < size; i++) {
                product[i] = this.field.multiply(this.coefficients[i], scalar);
              }
              return new GenericGFPoly(this.field, product);
            };
            GenericGFPoly.prototype.multiplyPoly = function (other) {
              if (this.isZero() || other.isZero()) {
                return this.field.zero;
              }
              var aCoefficients = this.coefficients;
              var aLength = aCoefficients.length;
              var bCoefficients = other.coefficients;
              var bLength = bCoefficients.length;
              var product = new Uint8ClampedArray(aLength + bLength - 1);
              for (var i = 0; i < aLength; i++) {
                var aCoeff = aCoefficients[i];
                for (var j = 0; j < bLength; j++) {
                  product[i + j] = GenericGF_1.addOrSubtractGF(
                    product[i + j],
                    this.field.multiply(aCoeff, bCoefficients[j])
                  );
                }
              }
              return new GenericGFPoly(this.field, product);
            };
            GenericGFPoly.prototype.multiplyByMonomial = function (
              degree,
              coefficient
            ) {
              if (degree < 0) {
                throw new Error("Invalid degree less than 0");
              }
              if (coefficient === 0) {
                return this.field.zero;
              }
              var size = this.coefficients.length;
              var product = new Uint8ClampedArray(size + degree);
              for (var i = 0; i < size; i++) {
                product[i] = this.field.multiply(
                  this.coefficients[i],
                  coefficient
                );
              }
              return new GenericGFPoly(this.field, product);
            };
            GenericGFPoly.prototype.evaluateAt = function (a) {
              var result = 0;
              if (a === 0) {
                // Just return the x^0 coefficient
                return this.getCoefficient(0);
              }
              var size = this.coefficients.length;
              if (a === 1) {
                // Just the sum of the coefficients
                this.coefficients.forEach(function (coefficient) {
                  result = GenericGF_1.addOrSubtractGF(result, coefficient);
                });
                return result;
              }
              result = this.coefficients[0];
              for (var i = 1; i < size; i++) {
                result = GenericGF_1.addOrSubtractGF(
                  this.field.multiply(a, result),
                  this.coefficients[i]
                );
              }
              return result;
            };
            return GenericGFPoly;
          })();
          exports.default = GenericGFPoly;
  
          /***/
        },
        /* 3 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var binarizer_1 = __webpack_require__(4);
          var decoder_1 = __webpack_require__(5);
          var extractor_1 = __webpack_require__(11);
          var locator_1 = __webpack_require__(12);
          function scan(matrix) {
            var locations = locator_1.locate(matrix);
            if (!locations) {
              return null;
            }
            for (
              var _i = 0, locations_1 = locations;
              _i < locations_1.length;
              _i++
            ) {
              var location_1 = locations_1[_i];
              var extracted = extractor_1.extract(matrix, location_1);
              var decoded = decoder_1.decode(extracted.matrix);
              if (decoded) {
                return {
                  binaryData: decoded.bytes,
                  data: decoded.text,
                  chunks: decoded.chunks,
                  version: decoded.version,
                  location: {
                    topRightCorner: extracted.mappingFunction(
                      location_1.dimension,
                      0
                    ),
                    topLeftCorner: extracted.mappingFunction(0, 0),
                    bottomRightCorner: extracted.mappingFunction(
                      location_1.dimension,
                      location_1.dimension
                    ),
                    bottomLeftCorner: extracted.mappingFunction(
                      0,
                      location_1.dimension
                    ),
                    topRightFinderPattern: location_1.topRight,
                    topLeftFinderPattern: location_1.topLeft,
                    bottomLeftFinderPattern: location_1.bottomLeft,
                    bottomRightAlignmentPattern: location_1.alignmentPattern,
                  },
                };
              }
            }
            return null;
          }
          var defaultOptions = {
            inversionAttempts: "attemptBoth",
          };
          function jsQR(data, width, height, providedOptions) {
            if (providedOptions === void 0) {
              providedOptions = {};
            }
            var options = defaultOptions;
            Object.keys(options || {}).forEach(function (opt) {
              options[opt] = providedOptions[opt] || options[opt];
            });
            var shouldInvert =
              options.inversionAttempts === "attemptBoth" ||
              options.inversionAttempts === "invertFirst";
            var tryInvertedFirst =
              options.inversionAttempts === "onlyInvert" ||
              options.inversionAttempts === "invertFirst";
            var _a = binarizer_1.binarize(data, width, height, shouldInvert),
              binarized = _a.binarized,
              inverted = _a.inverted;
            var result = scan(tryInvertedFirst ? inverted : binarized);
            if (
              !result &&
              (options.inversionAttempts === "attemptBoth" ||
                options.inversionAttempts === "invertFirst")
            ) {
              result = scan(tryInvertedFirst ? binarized : inverted);
            }
            return result;
          }
          jsQR.default = jsQR;
          exports.default = jsQR;
  
          /***/
        },
        /* 4 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var BitMatrix_1 = __webpack_require__(0);
          var REGION_SIZE = 8;
          var MIN_DYNAMIC_RANGE = 24;
          function numBetween(value, min, max) {
            return value < min ? min : value > max ? max : value;
          }
          // Like BitMatrix but accepts arbitry Uint8 values
          var Matrix = /** @class */ (function () {
            function Matrix(width, height) {
              this.width = width;
              this.data = new Uint8ClampedArray(width * height);
            }
            Matrix.prototype.get = function (x, y) {
              return this.data[y * this.width + x];
            };
            Matrix.prototype.set = function (x, y, value) {
              this.data[y * this.width + x] = value;
            };
            return Matrix;
          })();
          function binarize(data, width, height, returnInverted) {
            if (data.length !== width * height * 4) {
              throw new Error("Malformed data passed to binarizer.");
            }
            // Convert image to greyscale
            var greyscalePixels = new Matrix(width, height);
            for (var x = 0; x < width; x++) {
              for (var y = 0; y < height; y++) {
                var r = data[(y * width + x) * 4 + 0];
                var g = data[(y * width + x) * 4 + 1];
                var b = data[(y * width + x) * 4 + 2];
                greyscalePixels.set(x, y, 0.2126 * r + 0.7152 * g + 0.0722 * b);
              }
            }
            var horizontalRegionCount = Math.ceil(width / REGION_SIZE);
            var verticalRegionCount = Math.ceil(height / REGION_SIZE);
            var blackPoints = new Matrix(
              horizontalRegionCount,
              verticalRegionCount
            );
            for (
              var verticalRegion = 0;
              verticalRegion < verticalRegionCount;
              verticalRegion++
            ) {
              for (
                var hortizontalRegion = 0;
                hortizontalRegion < horizontalRegionCount;
                hortizontalRegion++
              ) {
                var sum = 0;
                var min = Infinity;
                var max = 0;
                for (var y = 0; y < REGION_SIZE; y++) {
                  for (var x = 0; x < REGION_SIZE; x++) {
                    var pixelLumosity = greyscalePixels.get(
                      hortizontalRegion * REGION_SIZE + x,
                      verticalRegion * REGION_SIZE + y
                    );
                    sum += pixelLumosity;
                    min = Math.min(min, pixelLumosity);
                    max = Math.max(max, pixelLumosity);
                  }
                }
                var average = sum / Math.pow(REGION_SIZE, 2);
                if (max - min <= MIN_DYNAMIC_RANGE) {
                  // If variation within the block is low, assume this is a block with only light or only
                  // dark pixels. In that case we do not want to use the average, as it would divide this
                  // low contrast area into black and white pixels, essentially creating data out of noise.
                  //
                  // Default the blackpoint for these blocks to be half the min - effectively white them out
                  average = min / 2;
                  if (verticalRegion > 0 && hortizontalRegion > 0) {
                    // Correct the "white background" assumption for blocks that have neighbors by comparing
                    // the pixels in this block to the previously calculated black points. This is based on
                    // the fact that dark barcode symbology is always surrounded by some amount of light
                    // background for which reasonable black point estimates were made. The bp estimated at
                    // the boundaries is used for the interior.
                    // The (min < bp) is arbitrary but works better than other heuristics that were tried.
                    var averageNeighborBlackPoint =
                      (blackPoints.get(hortizontalRegion, verticalRegion - 1) +
                        2 *
                          blackPoints.get(hortizontalRegion - 1, verticalRegion) +
                        blackPoints.get(
                          hortizontalRegion - 1,
                          verticalRegion - 1
                        )) /
                      4;
                    if (min < averageNeighborBlackPoint) {
                      average = averageNeighborBlackPoint;
                    }
                  }
                }
                blackPoints.set(hortizontalRegion, verticalRegion, average);
              }
            }
            var binarized = BitMatrix_1.BitMatrix.createEmpty(width, height);
            var inverted = null;
            if (returnInverted) {
              inverted = BitMatrix_1.BitMatrix.createEmpty(width, height);
            }
            for (
              var verticalRegion = 0;
              verticalRegion < verticalRegionCount;
              verticalRegion++
            ) {
              for (
                var hortizontalRegion = 0;
                hortizontalRegion < horizontalRegionCount;
                hortizontalRegion++
              ) {
                var left = numBetween(
                  hortizontalRegion,
                  2,
                  horizontalRegionCount - 3
                );
                var top_1 = numBetween(
                  verticalRegion,
                  2,
                  verticalRegionCount - 3
                );
                var sum = 0;
                for (var xRegion = -2; xRegion <= 2; xRegion++) {
                  for (var yRegion = -2; yRegion <= 2; yRegion++) {
                    sum += blackPoints.get(left + xRegion, top_1 + yRegion);
                  }
                }
                var threshold = sum / 25;
                for (var xRegion = 0; xRegion < REGION_SIZE; xRegion++) {
                  for (var yRegion = 0; yRegion < REGION_SIZE; yRegion++) {
                    var x = hortizontalRegion * REGION_SIZE + xRegion;
                    var y = verticalRegion * REGION_SIZE + yRegion;
                    var lum = greyscalePixels.get(x, y);
                    binarized.set(x, y, lum <= threshold);
                    if (returnInverted) {
                      inverted.set(x, y, !(lum <= threshold));
                    }
                  }
                }
              }
            }
            if (returnInverted) {
              return { binarized: binarized, inverted: inverted };
            }
            return { binarized: binarized };
          }
          exports.binarize = binarize;
  
          /***/
        },
        /* 5 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var BitMatrix_1 = __webpack_require__(0);
          var decodeData_1 = __webpack_require__(6);
          var reedsolomon_1 = __webpack_require__(9);
          var version_1 = __webpack_require__(10);
          // tslint:disable:no-bitwise
          function numBitsDiffering(x, y) {
            var z = x ^ y;
            var bitCount = 0;
            while (z) {
              bitCount++;
              z &= z - 1;
            }
            return bitCount;
          }
          function pushBit(bit, byte) {
            return (byte << 1) | bit;
          }
          // tslint:enable:no-bitwise
          var FORMAT_INFO_TABLE = [
            {
              bits: 0x5412,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 0 },
            },
            {
              bits: 0x5125,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 1 },
            },
            {
              bits: 0x5e7c,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 2 },
            },
            {
              bits: 0x5b4b,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 3 },
            },
            {
              bits: 0x45f9,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 4 },
            },
            {
              bits: 0x40ce,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 5 },
            },
            {
              bits: 0x4f97,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 6 },
            },
            {
              bits: 0x4aa0,
              formatInfo: { errorCorrectionLevel: 1, dataMask: 7 },
            },
            {
              bits: 0x77c4,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 0 },
            },
            {
              bits: 0x72f3,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 1 },
            },
            {
              bits: 0x7daa,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 2 },
            },
            {
              bits: 0x789d,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 3 },
            },
            {
              bits: 0x662f,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 4 },
            },
            {
              bits: 0x6318,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 5 },
            },
            {
              bits: 0x6c41,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 6 },
            },
            {
              bits: 0x6976,
              formatInfo: { errorCorrectionLevel: 0, dataMask: 7 },
            },
            {
              bits: 0x1689,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 0 },
            },
            {
              bits: 0x13be,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 1 },
            },
            {
              bits: 0x1ce7,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 2 },
            },
            {
              bits: 0x19d0,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 3 },
            },
            {
              bits: 0x0762,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 4 },
            },
            {
              bits: 0x0255,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 5 },
            },
            {
              bits: 0x0d0c,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 6 },
            },
            {
              bits: 0x083b,
              formatInfo: { errorCorrectionLevel: 3, dataMask: 7 },
            },
            {
              bits: 0x355f,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 0 },
            },
            {
              bits: 0x3068,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 1 },
            },
            {
              bits: 0x3f31,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 2 },
            },
            {
              bits: 0x3a06,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 3 },
            },
            {
              bits: 0x24b4,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 4 },
            },
            {
              bits: 0x2183,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 5 },
            },
            {
              bits: 0x2eda,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 6 },
            },
            {
              bits: 0x2bed,
              formatInfo: { errorCorrectionLevel: 2, dataMask: 7 },
            },
          ];
          var DATA_MASKS = [
            function (p) {
              return (p.y + p.x) % 2 === 0;
            },
            function (p) {
              return p.y % 2 === 0;
            },
            function (p) {
              return p.x % 3 === 0;
            },
            function (p) {
              return (p.y + p.x) % 3 === 0;
            },
            function (p) {
              return (Math.floor(p.y / 2) + Math.floor(p.x / 3)) % 2 === 0;
            },
            function (p) {
              return ((p.x * p.y) % 2) + ((p.x * p.y) % 3) === 0;
            },
            function (p) {
              return (((p.y * p.x) % 2) + ((p.y * p.x) % 3)) % 2 === 0;
            },
            function (p) {
              return (((p.y + p.x) % 2) + ((p.y * p.x) % 3)) % 2 === 0;
            },
          ];
          function buildFunctionPatternMask(version) {
            var dimension = 17 + 4 * version.versionNumber;
            var matrix = BitMatrix_1.BitMatrix.createEmpty(dimension, dimension);
            matrix.setRegion(0, 0, 9, 9, true); // Top left finder pattern + separator + format
            matrix.setRegion(dimension - 8, 0, 8, 9, true); // Top right finder pattern + separator + format
            matrix.setRegion(0, dimension - 8, 9, 8, true); // Bottom left finder pattern + separator + format
            // Alignment patterns
            for (
              var _i = 0, _a = version.alignmentPatternCenters;
              _i < _a.length;
              _i++
            ) {
              var x = _a[_i];
              for (
                var _b = 0, _c = version.alignmentPatternCenters;
                _b < _c.length;
                _b++
              ) {
                var y = _c[_b];
                if (
                  !(
                    (x === 6 && y === 6) ||
                    (x === 6 && y === dimension - 7) ||
                    (x === dimension - 7 && y === 6)
                  )
                ) {
                  matrix.setRegion(x - 2, y - 2, 5, 5, true);
                }
              }
            }
            matrix.setRegion(6, 9, 1, dimension - 17, true); // Vertical timing pattern
            matrix.setRegion(9, 6, dimension - 17, 1, true); // Horizontal timing pattern
            if (version.versionNumber > 6) {
              matrix.setRegion(dimension - 11, 0, 3, 6, true); // Version info, top right
              matrix.setRegion(0, dimension - 11, 6, 3, true); // Version info, bottom left
            }
            return matrix;
          }
          function readCodewords(matrix, version, formatInfo) {
            var dataMask = DATA_MASKS[formatInfo.dataMask];
            var dimension = matrix.height;
            var functionPatternMask = buildFunctionPatternMask(version);
            var codewords = [];
            var currentByte = 0;
            var bitsRead = 0;
            // Read columns in pairs, from right to left
            var readingUp = true;
            for (
              var columnIndex = dimension - 1;
              columnIndex > 0;
              columnIndex -= 2
            ) {
              if (columnIndex === 6) {
                // Skip whole column with vertical alignment pattern;
                columnIndex--;
              }
              for (var i = 0; i < dimension; i++) {
                var y = readingUp ? dimension - 1 - i : i;
                for (var columnOffset = 0; columnOffset < 2; columnOffset++) {
                  var x = columnIndex - columnOffset;
                  if (!functionPatternMask.get(x, y)) {
                    bitsRead++;
                    var bit = matrix.get(x, y);
                    if (dataMask({ y: y, x: x })) {
                      bit = !bit;
                    }
                    currentByte = pushBit(bit, currentByte);
                    if (bitsRead === 8) {
                      // Whole bytes
                      codewords.push(currentByte);
                      bitsRead = 0;
                      currentByte = 0;
                    }
                  }
                }
              }
              readingUp = !readingUp;
            }
            return codewords;
          }
          function readVersion(matrix) {
            var dimension = matrix.height;
            var provisionalVersion = Math.floor((dimension - 17) / 4);
            if (provisionalVersion <= 6) {
              // 6 and under dont have version info in the QR code
              return version_1.VERSIONS[provisionalVersion - 1];
            }
            var topRightVersionBits = 0;
            for (var y = 5; y >= 0; y--) {
              for (var x = dimension - 9; x >= dimension - 11; x--) {
                topRightVersionBits = pushBit(
                  matrix.get(x, y),
                  topRightVersionBits
                );
              }
            }
            var bottomLeftVersionBits = 0;
            for (var x = 5; x >= 0; x--) {
              for (var y = dimension - 9; y >= dimension - 11; y--) {
                bottomLeftVersionBits = pushBit(
                  matrix.get(x, y),
                  bottomLeftVersionBits
                );
              }
            }
            var bestDifference = Infinity;
            var bestVersion;
            for (
              var _i = 0, VERSIONS_1 = version_1.VERSIONS;
              _i < VERSIONS_1.length;
              _i++
            ) {
              var version = VERSIONS_1[_i];
              if (
                version.infoBits === topRightVersionBits ||
                version.infoBits === bottomLeftVersionBits
              ) {
                return version;
              }
              var difference = numBitsDiffering(
                topRightVersionBits,
                version.infoBits
              );
              if (difference < bestDifference) {
                bestVersion = version;
                bestDifference = difference;
              }
              difference = numBitsDiffering(
                bottomLeftVersionBits,
                version.infoBits
              );
              if (difference < bestDifference) {
                bestVersion = version;
                bestDifference = difference;
              }
            }
            // We can tolerate up to 3 bits of error since no two version info codewords will
            // differ in less than 8 bits.
            if (bestDifference <= 3) {
              return bestVersion;
            }
          }
          function readFormatInformation(matrix) {
            var topLeftFormatInfoBits = 0;
            for (var x = 0; x <= 8; x++) {
              if (x !== 6) {
                // Skip timing pattern bit
                topLeftFormatInfoBits = pushBit(
                  matrix.get(x, 8),
                  topLeftFormatInfoBits
                );
              }
            }
            for (var y = 7; y >= 0; y--) {
              if (y !== 6) {
                // Skip timing pattern bit
                topLeftFormatInfoBits = pushBit(
                  matrix.get(8, y),
                  topLeftFormatInfoBits
                );
              }
            }
            var dimension = matrix.height;
            var topRightBottomRightFormatInfoBits = 0;
            for (var y = dimension - 1; y >= dimension - 7; y--) {
              // bottom left
              topRightBottomRightFormatInfoBits = pushBit(
                matrix.get(8, y),
                topRightBottomRightFormatInfoBits
              );
            }
            for (var x = dimension - 8; x < dimension; x++) {
              // top right
              topRightBottomRightFormatInfoBits = pushBit(
                matrix.get(x, 8),
                topRightBottomRightFormatInfoBits
              );
            }
            var bestDifference = Infinity;
            var bestFormatInfo = null;
            for (
              var _i = 0, FORMAT_INFO_TABLE_1 = FORMAT_INFO_TABLE;
              _i < FORMAT_INFO_TABLE_1.length;
              _i++
            ) {
              var _a = FORMAT_INFO_TABLE_1[_i],
                bits = _a.bits,
                formatInfo = _a.formatInfo;
              if (
                bits === topLeftFormatInfoBits ||
                bits === topRightBottomRightFormatInfoBits
              ) {
                return formatInfo;
              }
              var difference = numBitsDiffering(topLeftFormatInfoBits, bits);
              if (difference < bestDifference) {
                bestFormatInfo = formatInfo;
                bestDifference = difference;
              }
              if (topLeftFormatInfoBits !== topRightBottomRightFormatInfoBits) {
                // also try the other option
                difference = numBitsDiffering(
                  topRightBottomRightFormatInfoBits,
                  bits
                );
                if (difference < bestDifference) {
                  bestFormatInfo = formatInfo;
                  bestDifference = difference;
                }
              }
            }
            // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits differing means we found a match
            if (bestDifference <= 3) {
              return bestFormatInfo;
            }
            return null;
          }
          function getDataBlocks(codewords, version, ecLevel) {
            var ecInfo = version.errorCorrectionLevels[ecLevel];
            var dataBlocks = [];
            var totalCodewords = 0;
            ecInfo.ecBlocks.forEach(function (block) {
              for (var i = 0; i < block.numBlocks; i++) {
                dataBlocks.push({
                  numDataCodewords: block.dataCodewordsPerBlock,
                  codewords: [],
                });
                totalCodewords +=
                  block.dataCodewordsPerBlock + ecInfo.ecCodewordsPerBlock;
              }
            });
            // In some cases the QR code will be malformed enough that we pull off more or less than we should.
            // If we pull off less there's nothing we can do.
            // If we pull off more we can safely truncate
            if (codewords.length < totalCodewords) {
              return null;
            }
            codewords = codewords.slice(0, totalCodewords);
            var shortBlockSize = ecInfo.ecBlocks[0].dataCodewordsPerBlock;
            // Pull codewords to fill the blocks up to the minimum size
            for (var i = 0; i < shortBlockSize; i++) {
              for (
                var _i = 0, dataBlocks_1 = dataBlocks;
                _i < dataBlocks_1.length;
                _i++
              ) {
                var dataBlock = dataBlocks_1[_i];
                dataBlock.codewords.push(codewords.shift());
              }
            }
            // If there are any large blocks, pull codewords to fill the last element of those
            if (ecInfo.ecBlocks.length > 1) {
              var smallBlockCount = ecInfo.ecBlocks[0].numBlocks;
              var largeBlockCount = ecInfo.ecBlocks[1].numBlocks;
              for (var i = 0; i < largeBlockCount; i++) {
                dataBlocks[smallBlockCount + i].codewords.push(codewords.shift());
              }
            }
            // Add the rest of the codewords to the blocks. These are the error correction codewords.
            while (codewords.length > 0) {
              for (
                var _a = 0, dataBlocks_2 = dataBlocks;
                _a < dataBlocks_2.length;
                _a++
              ) {
                var dataBlock = dataBlocks_2[_a];
                dataBlock.codewords.push(codewords.shift());
              }
            }
            return dataBlocks;
          }
          function decodeMatrix(matrix) {
            var version = readVersion(matrix);
            if (!version) {
              return null;
            }
            var formatInfo = readFormatInformation(matrix);
            if (!formatInfo) {
              return null;
            }
            var codewords = readCodewords(matrix, version, formatInfo);
            var dataBlocks = getDataBlocks(
              codewords,
              version,
              formatInfo.errorCorrectionLevel
            );
            if (!dataBlocks) {
              return null;
            }
            // Count total number of data bytes
            var totalBytes = dataBlocks.reduce(function (a, b) {
              return a + b.numDataCodewords;
            }, 0);
            var resultBytes = new Uint8ClampedArray(totalBytes);
            var resultIndex = 0;
            for (
              var _i = 0, dataBlocks_3 = dataBlocks;
              _i < dataBlocks_3.length;
              _i++
            ) {
              var dataBlock = dataBlocks_3[_i];
              var correctedBytes = reedsolomon_1.decode(
                dataBlock.codewords,
                dataBlock.codewords.length - dataBlock.numDataCodewords
              );
              if (!correctedBytes) {
                return null;
              }
              for (var i = 0; i < dataBlock.numDataCodewords; i++) {
                resultBytes[resultIndex++] = correctedBytes[i];
              }
            }
            try {
              return decodeData_1.decode(resultBytes, version.versionNumber);
            } catch (_a) {
              return null;
            }
          }
          function decode(matrix) {
            if (matrix == null) {
              return null;
            }
            var result = decodeMatrix(matrix);
            if (result) {
              return result;
            }
            // Decoding didn't work, try mirroring the QR across the topLeft -> bottomRight line.
            for (var x = 0; x < matrix.width; x++) {
              for (var y = x + 1; y < matrix.height; y++) {
                if (matrix.get(x, y) !== matrix.get(y, x)) {
                  matrix.set(x, y, !matrix.get(x, y));
                  matrix.set(y, x, !matrix.get(y, x));
                }
              }
            }
            return decodeMatrix(matrix);
          }
          exports.decode = decode;
  
          /***/
        },
        /* 6 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          // tslint:disable:no-bitwise
          var BitStream_1 = __webpack_require__(7);
          var shiftJISTable_1 = __webpack_require__(8);
          var Mode;
          (function (Mode) {
            Mode["Numeric"] = "numeric";
            Mode["Alphanumeric"] = "alphanumeric";
            Mode["Byte"] = "byte";
            Mode["Kanji"] = "kanji";
            Mode["ECI"] = "eci";
          })((Mode = exports.Mode || (exports.Mode = {})));
          var ModeByte;
          (function (ModeByte) {
            ModeByte[(ModeByte["Terminator"] = 0)] = "Terminator";
            ModeByte[(ModeByte["Numeric"] = 1)] = "Numeric";
            ModeByte[(ModeByte["Alphanumeric"] = 2)] = "Alphanumeric";
            ModeByte[(ModeByte["Byte"] = 4)] = "Byte";
            ModeByte[(ModeByte["Kanji"] = 8)] = "Kanji";
            ModeByte[(ModeByte["ECI"] = 7)] = "ECI";
            // StructuredAppend = 0x3,
            // FNC1FirstPosition = 0x5,
            // FNC1SecondPosition = 0x9,
          })(ModeByte || (ModeByte = {}));
          function decodeNumeric(stream, size) {
            var bytes = [];
            var text = "";
            var characterCountSize = [10, 12, 14][size];
            var length = stream.readBits(characterCountSize);
            // Read digits in groups of 3
            while (length >= 3) {
              var num = stream.readBits(10);
              if (num >= 1000) {
                throw new Error("Invalid numeric value above 999");
              }
              var a = Math.floor(num / 100);
              var b = Math.floor(num / 10) % 10;
              var c = num % 10;
              bytes.push(48 + a, 48 + b, 48 + c);
              text += a.toString() + b.toString() + c.toString();
              length -= 3;
            }
            // If the number of digits aren't a multiple of 3, the remaining digits are special cased.
            if (length === 2) {
              var num = stream.readBits(7);
              if (num >= 100) {
                throw new Error("Invalid numeric value above 99");
              }
              var a = Math.floor(num / 10);
              var b = num % 10;
              bytes.push(48 + a, 48 + b);
              text += a.toString() + b.toString();
            } else if (length === 1) {
              var num = stream.readBits(4);
              if (num >= 10) {
                throw new Error("Invalid numeric value above 9");
              }
              bytes.push(48 + num);
              text += num.toString();
            }
            return { bytes: bytes, text: text };
          }
          var AlphanumericCharacterCodes = [
            "0",
            "1",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "A",
            "B",
            "C",
            "D",
            "E",
            "F",
            "G",
            "H",
            "I",
            "J",
            "K",
            "L",
            "M",
            "N",
            "O",
            "P",
            "Q",
            "R",
            "S",
            "T",
            "U",
            "V",
            "W",
            "X",
            "Y",
            "Z",
            " ",
            "$",
            "%",
            "*",
            "+",
            "-",
            ".",
            "/",
            ":",
          ];
          function decodeAlphanumeric(stream, size) {
            var bytes = [];
            var text = "";
            var characterCountSize = [9, 11, 13][size];
            var length = stream.readBits(characterCountSize);
            while (length >= 2) {
              var v = stream.readBits(11);
              var a = Math.floor(v / 45);
              var b = v % 45;
              bytes.push(
                AlphanumericCharacterCodes[a].charCodeAt(0),
                AlphanumericCharacterCodes[b].charCodeAt(0)
              );
              text +=
                AlphanumericCharacterCodes[a] + AlphanumericCharacterCodes[b];
              length -= 2;
            }
            if (length === 1) {
              var a = stream.readBits(6);
              bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0));
              text += AlphanumericCharacterCodes[a];
            }
            return { bytes: bytes, text: text };
          }
          function decodeByte(stream, size) {
            var bytes = [];
            var text = "";
            var characterCountSize = [8, 16, 16][size];
            var length = stream.readBits(characterCountSize);
            for (var i = 0; i < length; i++) {
              var b = stream.readBits(8);
              bytes.push(b);
            }
            try {
              text += decodeURIComponent(
                bytes
                  .map(function (b) {
                    return "%" + ("0" + b.toString(16)).substr(-2);
                  })
                  .join("")
              );
            } catch (_a) {
              // failed to decode
            }
            return { bytes: bytes, text: text };
          }
          function decodeKanji(stream, size) {
            var bytes = [];
            var text = "";
            var characterCountSize = [8, 10, 12][size];
            var length = stream.readBits(characterCountSize);
            for (var i = 0; i < length; i++) {
              var k = stream.readBits(13);
              var c = (Math.floor(k / 0xc0) << 8) | k % 0xc0;
              if (c < 0x1f00) {
                c += 0x8140;
              } else {
                c += 0xc140;
              }
              bytes.push(c >> 8, c & 0xff);
              text += String.fromCharCode(shiftJISTable_1.shiftJISTable[c]);
            }
            return { bytes: bytes, text: text };
          }
          function decode(data, version) {
            var _a, _b, _c, _d;
            var stream = new BitStream_1.BitStream(data);
            // There are 3 'sizes' based on the version. 1-9 is small (0), 10-26 is medium (1) and 27-40 is large (2).
            var size = version <= 9 ? 0 : version <= 26 ? 1 : 2;
            var result = {
              text: "",
              bytes: [],
              chunks: [],
              version: version,
            };
            while (stream.available() >= 4) {
              var mode = stream.readBits(4);
              if (mode === ModeByte.Terminator) {
                return result;
              } else if (mode === ModeByte.ECI) {
                if (stream.readBits(1) === 0) {
                  result.chunks.push({
                    type: Mode.ECI,
                    assignmentNumber: stream.readBits(7),
                  });
                } else if (stream.readBits(1) === 0) {
                  result.chunks.push({
                    type: Mode.ECI,
                    assignmentNumber: stream.readBits(14),
                  });
                } else if (stream.readBits(1) === 0) {
                  result.chunks.push({
                    type: Mode.ECI,
                    assignmentNumber: stream.readBits(21),
                  });
                } else {
                  // ECI data seems corrupted
                  result.chunks.push({
                    type: Mode.ECI,
                    assignmentNumber: -1,
                  });
                }
              } else if (mode === ModeByte.Numeric) {
                var numericResult = decodeNumeric(stream, size);
                result.text += numericResult.text;
                (_a = result.bytes).push.apply(_a, numericResult.bytes);
                result.chunks.push({
                  type: Mode.Numeric,
                  text: numericResult.text,
                });
              } else if (mode === ModeByte.Alphanumeric) {
                var alphanumericResult = decodeAlphanumeric(stream, size);
                result.text += alphanumericResult.text;
                (_b = result.bytes).push.apply(_b, alphanumericResult.bytes);
                result.chunks.push({
                  type: Mode.Alphanumeric,
                  text: alphanumericResult.text,
                });
              } else if (mode === ModeByte.Byte) {
                var byteResult = decodeByte(stream, size);
                result.text += byteResult.text;
                (_c = result.bytes).push.apply(_c, byteResult.bytes);
                result.chunks.push({
                  type: Mode.Byte,
                  bytes: byteResult.bytes,
                  text: byteResult.text,
                });
              } else if (mode === ModeByte.Kanji) {
                var kanjiResult = decodeKanji(stream, size);
                result.text += kanjiResult.text;
                (_d = result.bytes).push.apply(_d, kanjiResult.bytes);
                result.chunks.push({
                  type: Mode.Kanji,
                  bytes: kanjiResult.bytes,
                  text: kanjiResult.text,
                });
              }
            }
            // If there is no data left, or the remaining bits are all 0, then that counts as a termination marker
            if (
              stream.available() === 0 ||
              stream.readBits(stream.available()) === 0
            ) {
              return result;
            }
          }
          exports.decode = decode;
  
          /***/
        },
        /* 7 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          // tslint:disable:no-bitwise
          Object.defineProperty(exports, "__esModule", { value: true });
          var BitStream = /** @class */ (function () {
            function BitStream(bytes) {
              this.byteOffset = 0;
              this.bitOffset = 0;
              this.bytes = bytes;
            }
            BitStream.prototype.readBits = function (numBits) {
              if (numBits < 1 || numBits > 32 || numBits > this.available()) {
                throw new Error("Cannot read " + numBits.toString() + " bits");
              }
              var result = 0;
              // First, read remainder from current byte
              if (this.bitOffset > 0) {
                var bitsLeft = 8 - this.bitOffset;
                var toRead = numBits < bitsLeft ? numBits : bitsLeft;
                var bitsToNotRead = bitsLeft - toRead;
                var mask = (0xff >> (8 - toRead)) << bitsToNotRead;
                result = (this.bytes[this.byteOffset] & mask) >> bitsToNotRead;
                numBits -= toRead;
                this.bitOffset += toRead;
                if (this.bitOffset === 8) {
                  this.bitOffset = 0;
                  this.byteOffset++;
                }
              }
              // Next read whole bytes
              if (numBits > 0) {
                while (numBits >= 8) {
                  result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
                  this.byteOffset++;
                  numBits -= 8;
                }
                // Finally read a partial byte
                if (numBits > 0) {
                  var bitsToNotRead = 8 - numBits;
                  var mask = (0xff >> bitsToNotRead) << bitsToNotRead;
                  result =
                    (result << numBits) |
                    ((this.bytes[this.byteOffset] & mask) >> bitsToNotRead);
                  this.bitOffset += numBits;
                }
              }
              return result;
            };
            BitStream.prototype.available = function () {
              return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
            };
            return BitStream;
          })();
          exports.BitStream = BitStream;
  
          /***/
        },
        /* 8 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          exports.shiftJISTable = {
            0x20: 0x0020,
            0x21: 0x0021,
            0x22: 0x0022,
            0x23: 0x0023,
            0x24: 0x0024,
            0x25: 0x0025,
            0x26: 0x0026,
            0x27: 0x0027,
            0x28: 0x0028,
            0x29: 0x0029,
            0x2a: 0x002a,
            0x2b: 0x002b,
            0x2c: 0x002c,
            0x2d: 0x002d,
            0x2e: 0x002e,
            0x2f: 0x002f,
            0x30: 0x0030,
            0x31: 0x0031,
            0x32: 0x0032,
            0x33: 0x0033,
            0x34: 0x0034,
            0x35: 0x0035,
            0x36: 0x0036,
            0x37: 0x0037,
            0x38: 0x0038,
            0x39: 0x0039,
            0x3a: 0x003a,
            0x3b: 0x003b,
            0x3c: 0x003c,
            0x3d: 0x003d,
            0x3e: 0x003e,
            0x3f: 0x003f,
            0x40: 0x0040,
            0x41: 0x0041,
            0x42: 0x0042,
            0x43: 0x0043,
            0x44: 0x0044,
            0x45: 0x0045,
            0x46: 0x0046,
            0x47: 0x0047,
            0x48: 0x0048,
            0x49: 0x0049,
            0x4a: 0x004a,
            0x4b: 0x004b,
            0x4c: 0x004c,
            0x4d: 0x004d,
            0x4e: 0x004e,
            0x4f: 0x004f,
            0x50: 0x0050,
            0x51: 0x0051,
            0x52: 0x0052,
            0x53: 0x0053,
            0x54: 0x0054,
            0x55: 0x0055,
            0x56: 0x0056,
            0x57: 0x0057,
            0x58: 0x0058,
            0x59: 0x0059,
            0x5a: 0x005a,
            0x5b: 0x005b,
            0x5c: 0x00a5,
            0x5d: 0x005d,
            0x5e: 0x005e,
            0x5f: 0x005f,
            0x60: 0x0060,
            0x61: 0x0061,
            0x62: 0x0062,
            0x63: 0x0063,
            0x64: 0x0064,
            0x65: 0x0065,
            0x66: 0x0066,
            0x67: 0x0067,
            0x68: 0x0068,
            0x69: 0x0069,
            0x6a: 0x006a,
            0x6b: 0x006b,
            0x6c: 0x006c,
            0x6d: 0x006d,
            0x6e: 0x006e,
            0x6f: 0x006f,
            0x70: 0x0070,
            0x71: 0x0071,
            0x72: 0x0072,
            0x73: 0x0073,
            0x74: 0x0074,
            0x75: 0x0075,
            0x76: 0x0076,
            0x77: 0x0077,
            0x78: 0x0078,
            0x79: 0x0079,
            0x7a: 0x007a,
            0x7b: 0x007b,
            0x7c: 0x007c,
            0x7d: 0x007d,
            0x7e: 0x203e,
            0x8140: 0x3000,
            0x8141: 0x3001,
            0x8142: 0x3002,
            0x8143: 0xff0c,
            0x8144: 0xff0e,
            0x8145: 0x30fb,
            0x8146: 0xff1a,
            0x8147: 0xff1b,
            0x8148: 0xff1f,
            0x8149: 0xff01,
            0x814a: 0x309b,
            0x814b: 0x309c,
            0x814c: 0x00b4,
            0x814d: 0xff40,
            0x814e: 0x00a8,
            0x814f: 0xff3e,
            0x8150: 0xffe3,
            0x8151: 0xff3f,
            0x8152: 0x30fd,
            0x8153: 0x30fe,
            0x8154: 0x309d,
            0x8155: 0x309e,
            0x8156: 0x3003,
            0x8157: 0x4edd,
            0x8158: 0x3005,
            0x8159: 0x3006,
            0x815a: 0x3007,
            0x815b: 0x30fc,
            0x815c: 0x2015,
            0x815d: 0x2010,
            0x815e: 0xff0f,
            0x815f: 0x005c,
            0x8160: 0x301c,
            0x8161: 0x2016,
            0x8162: 0xff5c,
            0x8163: 0x2026,
            0x8164: 0x2025,
            0x8165: 0x2018,
            0x8166: 0x2019,
            0x8167: 0x201c,
            0x8168: 0x201d,
            0x8169: 0xff08,
            0x816a: 0xff09,
            0x816b: 0x3014,
            0x816c: 0x3015,
            0x816d: 0xff3b,
            0x816e: 0xff3d,
            0x816f: 0xff5b,
            0x8170: 0xff5d,
            0x8171: 0x3008,
            0x8172: 0x3009,
            0x8173: 0x300a,
            0x8174: 0x300b,
            0x8175: 0x300c,
            0x8176: 0x300d,
            0x8177: 0x300e,
            0x8178: 0x300f,
            0x8179: 0x3010,
            0x817a: 0x3011,
            0x817b: 0xff0b,
            0x817c: 0x2212,
            0x817d: 0x00b1,
            0x817e: 0x00d7,
            0x8180: 0x00f7,
            0x8181: 0xff1d,
            0x8182: 0x2260,
            0x8183: 0xff1c,
            0x8184: 0xff1e,
            0x8185: 0x2266,
            0x8186: 0x2267,
            0x8187: 0x221e,
            0x8188: 0x2234,
            0x8189: 0x2642,
            0x818a: 0x2640,
            0x818b: 0x00b0,
            0x818c: 0x2032,
            0x818d: 0x2033,
            0x818e: 0x2103,
            0x818f: 0xffe5,
            0x8190: 0xff04,
            0x8191: 0x00a2,
            0x8192: 0x00a3,
            0x8193: 0xff05,
            0x8194: 0xff03,
            0x8195: 0xff06,
            0x8196: 0xff0a,
            0x8197: 0xff20,
            0x8198: 0x00a7,
            0x8199: 0x2606,
            0x819a: 0x2605,
            0x819b: 0x25cb,
            0x819c: 0x25cf,
            0x819d: 0x25ce,
            0x819e: 0x25c7,
            0x819f: 0x25c6,
            0x81a0: 0x25a1,
            0x81a1: 0x25a0,
            0x81a2: 0x25b3,
            0x81a3: 0x25b2,
            0x81a4: 0x25bd,
            0x81a5: 0x25bc,
            0x81a6: 0x203b,
            0x81a7: 0x3012,
            0x81a8: 0x2192,
            0x81a9: 0x2190,
            0x81aa: 0x2191,
            0x81ab: 0x2193,
            0x81ac: 0x3013,
            0x81b8: 0x2208,
            0x81b9: 0x220b,
            0x81ba: 0x2286,
            0x81bb: 0x2287,
            0x81bc: 0x2282,
            0x81bd: 0x2283,
            0x81be: 0x222a,
            0x81bf: 0x2229,
            0x81c8: 0x2227,
            0x81c9: 0x2228,
            0x81ca: 0x00ac,
            0x81cb: 0x21d2,
            0x81cc: 0x21d4,
            0x81cd: 0x2200,
            0x81ce: 0x2203,
            0x81da: 0x2220,
            0x81db: 0x22a5,
            0x81dc: 0x2312,
            0x81dd: 0x2202,
            0x81de: 0x2207,
            0x81df: 0x2261,
            0x81e0: 0x2252,
            0x81e1: 0x226a,
            0x81e2: 0x226b,
            0x81e3: 0x221a,
            0x81e4: 0x223d,
            0x81e5: 0x221d,
            0x81e6: 0x2235,
            0x81e7: 0x222b,
            0x81e8: 0x222c,
            0x81f0: 0x212b,
            0x81f1: 0x2030,
            0x81f2: 0x266f,
            0x81f3: 0x266d,
            0x81f4: 0x266a,
            0x81f5: 0x2020,
            0x81f6: 0x2021,
            0x81f7: 0x00b6,
            0x81fc: 0x25ef,
            0x824f: 0xff10,
            0x8250: 0xff11,
            0x8251: 0xff12,
            0x8252: 0xff13,
            0x8253: 0xff14,
            0x8254: 0xff15,
            0x8255: 0xff16,
            0x8256: 0xff17,
            0x8257: 0xff18,
            0x8258: 0xff19,
            0x8260: 0xff21,
            0x8261: 0xff22,
            0x8262: 0xff23,
            0x8263: 0xff24,
            0x8264: 0xff25,
            0x8265: 0xff26,
            0x8266: 0xff27,
            0x8267: 0xff28,
            0x8268: 0xff29,
            0x8269: 0xff2a,
            0x826a: 0xff2b,
            0x826b: 0xff2c,
            0x826c: 0xff2d,
            0x826d: 0xff2e,
            0x826e: 0xff2f,
            0x826f: 0xff30,
            0x8270: 0xff31,
            0x8271: 0xff32,
            0x8272: 0xff33,
            0x8273: 0xff34,
            0x8274: 0xff35,
            0x8275: 0xff36,
            0x8276: 0xff37,
            0x8277: 0xff38,
            0x8278: 0xff39,
            0x8279: 0xff3a,
            0x8281: 0xff41,
            0x8282: 0xff42,
            0x8283: 0xff43,
            0x8284: 0xff44,
            0x8285: 0xff45,
            0x8286: 0xff46,
            0x8287: 0xff47,
            0x8288: 0xff48,
            0x8289: 0xff49,
            0x828a: 0xff4a,
            0x828b: 0xff4b,
            0x828c: 0xff4c,
            0x828d: 0xff4d,
            0x828e: 0xff4e,
            0x828f: 0xff4f,
            0x8290: 0xff50,
            0x8291: 0xff51,
            0x8292: 0xff52,
            0x8293: 0xff53,
            0x8294: 0xff54,
            0x8295: 0xff55,
            0x8296: 0xff56,
            0x8297: 0xff57,
            0x8298: 0xff58,
            0x8299: 0xff59,
            0x829a: 0xff5a,
            0x829f: 0x3041,
            0x82a0: 0x3042,
            0x82a1: 0x3043,
            0x82a2: 0x3044,
            0x82a3: 0x3045,
            0x82a4: 0x3046,
            0x82a5: 0x3047,
            0x82a6: 0x3048,
            0x82a7: 0x3049,
            0x82a8: 0x304a,
            0x82a9: 0x304b,
            0x82aa: 0x304c,
            0x82ab: 0x304d,
            0x82ac: 0x304e,
            0x82ad: 0x304f,
            0x82ae: 0x3050,
            0x82af: 0x3051,
            0x82b0: 0x3052,
            0x82b1: 0x3053,
            0x82b2: 0x3054,
            0x82b3: 0x3055,
            0x82b4: 0x3056,
            0x82b5: 0x3057,
            0x82b6: 0x3058,
            0x82b7: 0x3059,
            0x82b8: 0x305a,
            0x82b9: 0x305b,
            0x82ba: 0x305c,
            0x82bb: 0x305d,
            0x82bc: 0x305e,
            0x82bd: 0x305f,
            0x82be: 0x3060,
            0x82bf: 0x3061,
            0x82c0: 0x3062,
            0x82c1: 0x3063,
            0x82c2: 0x3064,
            0x82c3: 0x3065,
            0x82c4: 0x3066,
            0x82c5: 0x3067,
            0x82c6: 0x3068,
            0x82c7: 0x3069,
            0x82c8: 0x306a,
            0x82c9: 0x306b,
            0x82ca: 0x306c,
            0x82cb: 0x306d,
            0x82cc: 0x306e,
            0x82cd: 0x306f,
            0x82ce: 0x3070,
            0x82cf: 0x3071,
            0x82d0: 0x3072,
            0x82d1: 0x3073,
            0x82d2: 0x3074,
            0x82d3: 0x3075,
            0x82d4: 0x3076,
            0x82d5: 0x3077,
            0x82d6: 0x3078,
            0x82d7: 0x3079,
            0x82d8: 0x307a,
            0x82d9: 0x307b,
            0x82da: 0x307c,
            0x82db: 0x307d,
            0x82dc: 0x307e,
            0x82dd: 0x307f,
            0x82de: 0x3080,
            0x82df: 0x3081,
            0x82e0: 0x3082,
            0x82e1: 0x3083,
            0x82e2: 0x3084,
            0x82e3: 0x3085,
            0x82e4: 0x3086,
            0x82e5: 0x3087,
            0x82e6: 0x3088,
            0x82e7: 0x3089,
            0x82e8: 0x308a,
            0x82e9: 0x308b,
            0x82ea: 0x308c,
            0x82eb: 0x308d,
            0x82ec: 0x308e,
            0x82ed: 0x308f,
            0x82ee: 0x3090,
            0x82ef: 0x3091,
            0x82f0: 0x3092,
            0x82f1: 0x3093,
            0x8340: 0x30a1,
            0x8341: 0x30a2,
            0x8342: 0x30a3,
            0x8343: 0x30a4,
            0x8344: 0x30a5,
            0x8345: 0x30a6,
            0x8346: 0x30a7,
            0x8347: 0x30a8,
            0x8348: 0x30a9,
            0x8349: 0x30aa,
            0x834a: 0x30ab,
            0x834b: 0x30ac,
            0x834c: 0x30ad,
            0x834d: 0x30ae,
            0x834e: 0x30af,
            0x834f: 0x30b0,
            0x8350: 0x30b1,
            0x8351: 0x30b2,
            0x8352: 0x30b3,
            0x8353: 0x30b4,
            0x8354: 0x30b5,
            0x8355: 0x30b6,
            0x8356: 0x30b7,
            0x8357: 0x30b8,
            0x8358: 0x30b9,
            0x8359: 0x30ba,
            0x835a: 0x30bb,
            0x835b: 0x30bc,
            0x835c: 0x30bd,
            0x835d: 0x30be,
            0x835e: 0x30bf,
            0x835f: 0x30c0,
            0x8360: 0x30c1,
            0x8361: 0x30c2,
            0x8362: 0x30c3,
            0x8363: 0x30c4,
            0x8364: 0x30c5,
            0x8365: 0x30c6,
            0x8366: 0x30c7,
            0x8367: 0x30c8,
            0x8368: 0x30c9,
            0x8369: 0x30ca,
            0x836a: 0x30cb,
            0x836b: 0x30cc,
            0x836c: 0x30cd,
            0x836d: 0x30ce,
            0x836e: 0x30cf,
            0x836f: 0x30d0,
            0x8370: 0x30d1,
            0x8371: 0x30d2,
            0x8372: 0x30d3,
            0x8373: 0x30d4,
            0x8374: 0x30d5,
            0x8375: 0x30d6,
            0x8376: 0x30d7,
            0x8377: 0x30d8,
            0x8378: 0x30d9,
            0x8379: 0x30da,
            0x837a: 0x30db,
            0x837b: 0x30dc,
            0x837c: 0x30dd,
            0x837d: 0x30de,
            0x837e: 0x30df,
            0x8380: 0x30e0,
            0x8381: 0x30e1,
            0x8382: 0x30e2,
            0x8383: 0x30e3,
            0x8384: 0x30e4,
            0x8385: 0x30e5,
            0x8386: 0x30e6,
            0x8387: 0x30e7,
            0x8388: 0x30e8,
            0x8389: 0x30e9,
            0x838a: 0x30ea,
            0x838b: 0x30eb,
            0x838c: 0x30ec,
            0x838d: 0x30ed,
            0x838e: 0x30ee,
            0x838f: 0x30ef,
            0x8390: 0x30f0,
            0x8391: 0x30f1,
            0x8392: 0x30f2,
            0x8393: 0x30f3,
            0x8394: 0x30f4,
            0x8395: 0x30f5,
            0x8396: 0x30f6,
            0x839f: 0x0391,
            0x83a0: 0x0392,
            0x83a1: 0x0393,
            0x83a2: 0x0394,
            0x83a3: 0x0395,
            0x83a4: 0x0396,
            0x83a5: 0x0397,
            0x83a6: 0x0398,
            0x83a7: 0x0399,
            0x83a8: 0x039a,
            0x83a9: 0x039b,
            0x83aa: 0x039c,
            0x83ab: 0x039d,
            0x83ac: 0x039e,
            0x83ad: 0x039f,
            0x83ae: 0x03a0,
            0x83af: 0x03a1,
            0x83b0: 0x03a3,
            0x83b1: 0x03a4,
            0x83b2: 0x03a5,
            0x83b3: 0x03a6,
            0x83b4: 0x03a7,
            0x83b5: 0x03a8,
            0x83b6: 0x03a9,
            0x83bf: 0x03b1,
            0x83c0: 0x03b2,
            0x83c1: 0x03b3,
            0x83c2: 0x03b4,
            0x83c3: 0x03b5,
            0x83c4: 0x03b6,
            0x83c5: 0x03b7,
            0x83c6: 0x03b8,
            0x83c7: 0x03b9,
            0x83c8: 0x03ba,
            0x83c9: 0x03bb,
            0x83ca: 0x03bc,
            0x83cb: 0x03bd,
            0x83cc: 0x03be,
            0x83cd: 0x03bf,
            0x83ce: 0x03c0,
            0x83cf: 0x03c1,
            0x83d0: 0x03c3,
            0x83d1: 0x03c4,
            0x83d2: 0x03c5,
            0x83d3: 0x03c6,
            0x83d4: 0x03c7,
            0x83d5: 0x03c8,
            0x83d6: 0x03c9,
            0x8440: 0x0410,
            0x8441: 0x0411,
            0x8442: 0x0412,
            0x8443: 0x0413,
            0x8444: 0x0414,
            0x8445: 0x0415,
            0x8446: 0x0401,
            0x8447: 0x0416,
            0x8448: 0x0417,
            0x8449: 0x0418,
            0x844a: 0x0419,
            0x844b: 0x041a,
            0x844c: 0x041b,
            0x844d: 0x041c,
            0x844e: 0x041d,
            0x844f: 0x041e,
            0x8450: 0x041f,
            0x8451: 0x0420,
            0x8452: 0x0421,
            0x8453: 0x0422,
            0x8454: 0x0423,
            0x8455: 0x0424,
            0x8456: 0x0425,
            0x8457: 0x0426,
            0x8458: 0x0427,
            0x8459: 0x0428,
            0x845a: 0x0429,
            0x845b: 0x042a,
            0x845c: 0x042b,
            0x845d: 0x042c,
            0x845e: 0x042d,
            0x845f: 0x042e,
            0x8460: 0x042f,
            0x8470: 0x0430,
            0x8471: 0x0431,
            0x8472: 0x0432,
            0x8473: 0x0433,
            0x8474: 0x0434,
            0x8475: 0x0435,
            0x8476: 0x0451,
            0x8477: 0x0436,
            0x8478: 0x0437,
            0x8479: 0x0438,
            0x847a: 0x0439,
            0x847b: 0x043a,
            0x847c: 0x043b,
            0x847d: 0x043c,
            0x847e: 0x043d,
            0x8480: 0x043e,
            0x8481: 0x043f,
            0x8482: 0x0440,
            0x8483: 0x0441,
            0x8484: 0x0442,
            0x8485: 0x0443,
            0x8486: 0x0444,
            0x8487: 0x0445,
            0x8488: 0x0446,
            0x8489: 0x0447,
            0x848a: 0x0448,
            0x848b: 0x0449,
            0x848c: 0x044a,
            0x848d: 0x044b,
            0x848e: 0x044c,
            0x848f: 0x044d,
            0x8490: 0x044e,
            0x8491: 0x044f,
            0x849f: 0x2500,
            0x84a0: 0x2502,
            0x84a1: 0x250c,
            0x84a2: 0x2510,
            0x84a3: 0x2518,
            0x84a4: 0x2514,
            0x84a5: 0x251c,
            0x84a6: 0x252c,
            0x84a7: 0x2524,
            0x84a8: 0x2534,
            0x84a9: 0x253c,
            0x84aa: 0x2501,
            0x84ab: 0x2503,
            0x84ac: 0x250f,
            0x84ad: 0x2513,
            0x84ae: 0x251b,
            0x84af: 0x2517,
            0x84b0: 0x2523,
            0x84b1: 0x2533,
            0x84b2: 0x252b,
            0x84b3: 0x253b,
            0x84b4: 0x254b,
            0x84b5: 0x2520,
            0x84b6: 0x252f,
            0x84b7: 0x2528,
            0x84b8: 0x2537,
            0x84b9: 0x253f,
            0x84ba: 0x251d,
            0x84bb: 0x2530,
            0x84bc: 0x2525,
            0x84bd: 0x2538,
            0x84be: 0x2542,
            0x889f: 0x4e9c,
            0x88a0: 0x5516,
            0x88a1: 0x5a03,
            0x88a2: 0x963f,
            0x88a3: 0x54c0,
            0x88a4: 0x611b,
            0x88a5: 0x6328,
            0x88a6: 0x59f6,
            0x88a7: 0x9022,
            0x88a8: 0x8475,
            0x88a9: 0x831c,
            0x88aa: 0x7a50,
            0x88ab: 0x60aa,
            0x88ac: 0x63e1,
            0x88ad: 0x6e25,
            0x88ae: 0x65ed,
            0x88af: 0x8466,
            0x88b0: 0x82a6,
            0x88b1: 0x9bf5,
            0x88b2: 0x6893,
            0x88b3: 0x5727,
            0x88b4: 0x65a1,
            0x88b5: 0x6271,
            0x88b6: 0x5b9b,
            0x88b7: 0x59d0,
            0x88b8: 0x867b,
            0x88b9: 0x98f4,
            0x88ba: 0x7d62,
            0x88bb: 0x7dbe,
            0x88bc: 0x9b8e,
            0x88bd: 0x6216,
            0x88be: 0x7c9f,
            0x88bf: 0x88b7,
            0x88c0: 0x5b89,
            0x88c1: 0x5eb5,
            0x88c2: 0x6309,
            0x88c3: 0x6697,
            0x88c4: 0x6848,
            0x88c5: 0x95c7,
            0x88c6: 0x978d,
            0x88c7: 0x674f,
            0x88c8: 0x4ee5,
            0x88c9: 0x4f0a,
            0x88ca: 0x4f4d,
            0x88cb: 0x4f9d,
            0x88cc: 0x5049,
            0x88cd: 0x56f2,
            0x88ce: 0x5937,
            0x88cf: 0x59d4,
            0x88d0: 0x5a01,
            0x88d1: 0x5c09,
            0x88d2: 0x60df,
            0x88d3: 0x610f,
            0x88d4: 0x6170,
            0x88d5: 0x6613,
            0x88d6: 0x6905,
            0x88d7: 0x70ba,
            0x88d8: 0x754f,
            0x88d9: 0x7570,
            0x88da: 0x79fb,
            0x88db: 0x7dad,
            0x88dc: 0x7def,
            0x88dd: 0x80c3,
            0x88de: 0x840e,
            0x88df: 0x8863,
            0x88e0: 0x8b02,
            0x88e1: 0x9055,
            0x88e2: 0x907a,
            0x88e3: 0x533b,
            0x88e4: 0x4e95,
            0x88e5: 0x4ea5,
            0x88e6: 0x57df,
            0x88e7: 0x80b2,
            0x88e8: 0x90c1,
            0x88e9: 0x78ef,
            0x88ea: 0x4e00,
            0x88eb: 0x58f1,
            0x88ec: 0x6ea2,
            0x88ed: 0x9038,
            0x88ee: 0x7a32,
            0x88ef: 0x8328,
            0x88f0: 0x828b,
            0x88f1: 0x9c2f,
            0x88f2: 0x5141,
            0x88f3: 0x5370,
            0x88f4: 0x54bd,
            0x88f5: 0x54e1,
            0x88f6: 0x56e0,
            0x88f7: 0x59fb,
            0x88f8: 0x5f15,
            0x88f9: 0x98f2,
            0x88fa: 0x6deb,
            0x88fb: 0x80e4,
            0x88fc: 0x852d,
            0x8940: 0x9662,
            0x8941: 0x9670,
            0x8942: 0x96a0,
            0x8943: 0x97fb,
            0x8944: 0x540b,
            0x8945: 0x53f3,
            0x8946: 0x5b87,
            0x8947: 0x70cf,
            0x8948: 0x7fbd,
            0x8949: 0x8fc2,
            0x894a: 0x96e8,
            0x894b: 0x536f,
            0x894c: 0x9d5c,
            0x894d: 0x7aba,
            0x894e: 0x4e11,
            0x894f: 0x7893,
            0x8950: 0x81fc,
            0x8951: 0x6e26,
            0x8952: 0x5618,
            0x8953: 0x5504,
            0x8954: 0x6b1d,
            0x8955: 0x851a,
            0x8956: 0x9c3b,
            0x8957: 0x59e5,
            0x8958: 0x53a9,
            0x8959: 0x6d66,
            0x895a: 0x74dc,
            0x895b: 0x958f,
            0x895c: 0x5642,
            0x895d: 0x4e91,
            0x895e: 0x904b,
            0x895f: 0x96f2,
            0x8960: 0x834f,
            0x8961: 0x990c,
            0x8962: 0x53e1,
            0x8963: 0x55b6,
            0x8964: 0x5b30,
            0x8965: 0x5f71,
            0x8966: 0x6620,
            0x8967: 0x66f3,
            0x8968: 0x6804,
            0x8969: 0x6c38,
            0x896a: 0x6cf3,
            0x896b: 0x6d29,
            0x896c: 0x745b,
            0x896d: 0x76c8,
            0x896e: 0x7a4e,
            0x896f: 0x9834,
            0x8970: 0x82f1,
            0x8971: 0x885b,
            0x8972: 0x8a60,
            0x8973: 0x92ed,
            0x8974: 0x6db2,
            0x8975: 0x75ab,
            0x8976: 0x76ca,
            0x8977: 0x99c5,
            0x8978: 0x60a6,
            0x8979: 0x8b01,
            0x897a: 0x8d8a,
            0x897b: 0x95b2,
            0x897c: 0x698e,
            0x897d: 0x53ad,
            0x897e: 0x5186,
            0x8980: 0x5712,
            0x8981: 0x5830,
            0x8982: 0x5944,
            0x8983: 0x5bb4,
            0x8984: 0x5ef6,
            0x8985: 0x6028,
            0x8986: 0x63a9,
            0x8987: 0x63f4,
            0x8988: 0x6cbf,
            0x8989: 0x6f14,
            0x898a: 0x708e,
            0x898b: 0x7114,
            0x898c: 0x7159,
            0x898d: 0x71d5,
            0x898e: 0x733f,
            0x898f: 0x7e01,
            0x8990: 0x8276,
            0x8991: 0x82d1,
            0x8992: 0x8597,
            0x8993: 0x9060,
            0x8994: 0x925b,
            0x8995: 0x9d1b,
            0x8996: 0x5869,
            0x8997: 0x65bc,
            0x8998: 0x6c5a,
            0x8999: 0x7525,
            0x899a: 0x51f9,
            0x899b: 0x592e,
            0x899c: 0x5965,
            0x899d: 0x5f80,
            0x899e: 0x5fdc,
            0x899f: 0x62bc,
            0x89a0: 0x65fa,
            0x89a1: 0x6a2a,
            0x89a2: 0x6b27,
            0x89a3: 0x6bb4,
            0x89a4: 0x738b,
            0x89a5: 0x7fc1,
            0x89a6: 0x8956,
            0x89a7: 0x9d2c,
            0x89a8: 0x9d0e,
            0x89a9: 0x9ec4,
            0x89aa: 0x5ca1,
            0x89ab: 0x6c96,
            0x89ac: 0x837b,
            0x89ad: 0x5104,
            0x89ae: 0x5c4b,
            0x89af: 0x61b6,
            0x89b0: 0x81c6,
            0x89b1: 0x6876,
            0x89b2: 0x7261,
            0x89b3: 0x4e59,
            0x89b4: 0x4ffa,
            0x89b5: 0x5378,
            0x89b6: 0x6069,
            0x89b7: 0x6e29,
            0x89b8: 0x7a4f,
            0x89b9: 0x97f3,
            0x89ba: 0x4e0b,
            0x89bb: 0x5316,
            0x89bc: 0x4eee,
            0x89bd: 0x4f55,
            0x89be: 0x4f3d,
            0x89bf: 0x4fa1,
            0x89c0: 0x4f73,
            0x89c1: 0x52a0,
            0x89c2: 0x53ef,
            0x89c3: 0x5609,
            0x89c4: 0x590f,
            0x89c5: 0x5ac1,
            0x89c6: 0x5bb6,
            0x89c7: 0x5be1,
            0x89c8: 0x79d1,
            0x89c9: 0x6687,
            0x89ca: 0x679c,
            0x89cb: 0x67b6,
            0x89cc: 0x6b4c,
            0x89cd: 0x6cb3,
            0x89ce: 0x706b,
            0x89cf: 0x73c2,
            0x89d0: 0x798d,
            0x89d1: 0x79be,
            0x89d2: 0x7a3c,
            0x89d3: 0x7b87,
            0x89d4: 0x82b1,
            0x89d5: 0x82db,
            0x89d6: 0x8304,
            0x89d7: 0x8377,
            0x89d8: 0x83ef,
            0x89d9: 0x83d3,
            0x89da: 0x8766,
            0x89db: 0x8ab2,
            0x89dc: 0x5629,
            0x89dd: 0x8ca8,
            0x89de: 0x8fe6,
            0x89df: 0x904e,
            0x89e0: 0x971e,
            0x89e1: 0x868a,
            0x89e2: 0x4fc4,
            0x89e3: 0x5ce8,
            0x89e4: 0x6211,
            0x89e5: 0x7259,
            0x89e6: 0x753b,
            0x89e7: 0x81e5,
            0x89e8: 0x82bd,
            0x89e9: 0x86fe,
            0x89ea: 0x8cc0,
            0x89eb: 0x96c5,
            0x89ec: 0x9913,
            0x89ed: 0x99d5,
            0x89ee: 0x4ecb,
            0x89ef: 0x4f1a,
            0x89f0: 0x89e3,
            0x89f1: 0x56de,
            0x89f2: 0x584a,
            0x89f3: 0x58ca,
            0x89f4: 0x5efb,
            0x89f5: 0x5feb,
            0x89f6: 0x602a,
            0x89f7: 0x6094,
            0x89f8: 0x6062,
            0x89f9: 0x61d0,
            0x89fa: 0x6212,
            0x89fb: 0x62d0,
            0x89fc: 0x6539,
            0x8a40: 0x9b41,
            0x8a41: 0x6666,
            0x8a42: 0x68b0,
            0x8a43: 0x6d77,
            0x8a44: 0x7070,
            0x8a45: 0x754c,
            0x8a46: 0x7686,
            0x8a47: 0x7d75,
            0x8a48: 0x82a5,
            0x8a49: 0x87f9,
            0x8a4a: 0x958b,
            0x8a4b: 0x968e,
            0x8a4c: 0x8c9d,
            0x8a4d: 0x51f1,
            0x8a4e: 0x52be,
            0x8a4f: 0x5916,
            0x8a50: 0x54b3,
            0x8a51: 0x5bb3,
            0x8a52: 0x5d16,
            0x8a53: 0x6168,
            0x8a54: 0x6982,
            0x8a55: 0x6daf,
            0x8a56: 0x788d,
            0x8a57: 0x84cb,
            0x8a58: 0x8857,
            0x8a59: 0x8a72,
            0x8a5a: 0x93a7,
            0x8a5b: 0x9ab8,
            0x8a5c: 0x6d6c,
            0x8a5d: 0x99a8,
            0x8a5e: 0x86d9,
            0x8a5f: 0x57a3,
            0x8a60: 0x67ff,
            0x8a61: 0x86ce,
            0x8a62: 0x920e,
            0x8a63: 0x5283,
            0x8a64: 0x5687,
            0x8a65: 0x5404,
            0x8a66: 0x5ed3,
            0x8a67: 0x62e1,
            0x8a68: 0x64b9,
            0x8a69: 0x683c,
            0x8a6a: 0x6838,
            0x8a6b: 0x6bbb,
            0x8a6c: 0x7372,
            0x8a6d: 0x78ba,
            0x8a6e: 0x7a6b,
            0x8a6f: 0x899a,
            0x8a70: 0x89d2,
            0x8a71: 0x8d6b,
            0x8a72: 0x8f03,
            0x8a73: 0x90ed,
            0x8a74: 0x95a3,
            0x8a75: 0x9694,
            0x8a76: 0x9769,
            0x8a77: 0x5b66,
            0x8a78: 0x5cb3,
            0x8a79: 0x697d,
            0x8a7a: 0x984d,
            0x8a7b: 0x984e,
            0x8a7c: 0x639b,
            0x8a7d: 0x7b20,
            0x8a7e: 0x6a2b,
            0x8a80: 0x6a7f,
            0x8a81: 0x68b6,
            0x8a82: 0x9c0d,
            0x8a83: 0x6f5f,
            0x8a84: 0x5272,
            0x8a85: 0x559d,
            0x8a86: 0x6070,
            0x8a87: 0x62ec,
            0x8a88: 0x6d3b,
            0x8a89: 0x6e07,
            0x8a8a: 0x6ed1,
            0x8a8b: 0x845b,
            0x8a8c: 0x8910,
            0x8a8d: 0x8f44,
            0x8a8e: 0x4e14,
            0x8a8f: 0x9c39,
            0x8a90: 0x53f6,
            0x8a91: 0x691b,
            0x8a92: 0x6a3a,
            0x8a93: 0x9784,
            0x8a94: 0x682a,
            0x8a95: 0x515c,
            0x8a96: 0x7ac3,
            0x8a97: 0x84b2,
            0x8a98: 0x91dc,
            0x8a99: 0x938c,
            0x8a9a: 0x565b,
            0x8a9b: 0x9d28,
            0x8a9c: 0x6822,
            0x8a9d: 0x8305,
            0x8a9e: 0x8431,
            0x8a9f: 0x7ca5,
            0x8aa0: 0x5208,
            0x8aa1: 0x82c5,
            0x8aa2: 0x74e6,
            0x8aa3: 0x4e7e,
            0x8aa4: 0x4f83,
            0x8aa5: 0x51a0,
            0x8aa6: 0x5bd2,
            0x8aa7: 0x520a,
            0x8aa8: 0x52d8,
            0x8aa9: 0x52e7,
            0x8aaa: 0x5dfb,
            0x8aab: 0x559a,
            0x8aac: 0x582a,
            0x8aad: 0x59e6,
            0x8aae: 0x5b8c,
            0x8aaf: 0x5b98,
            0x8ab0: 0x5bdb,
            0x8ab1: 0x5e72,
            0x8ab2: 0x5e79,
            0x8ab3: 0x60a3,
            0x8ab4: 0x611f,
            0x8ab5: 0x6163,
            0x8ab6: 0x61be,
            0x8ab7: 0x63db,
            0x8ab8: 0x6562,
            0x8ab9: 0x67d1,
            0x8aba: 0x6853,
            0x8abb: 0x68fa,
            0x8abc: 0x6b3e,
            0x8abd: 0x6b53,
            0x8abe: 0x6c57,
            0x8abf: 0x6f22,
            0x8ac0: 0x6f97,
            0x8ac1: 0x6f45,
            0x8ac2: 0x74b0,
            0x8ac3: 0x7518,
            0x8ac4: 0x76e3,
            0x8ac5: 0x770b,
            0x8ac6: 0x7aff,
            0x8ac7: 0x7ba1,
            0x8ac8: 0x7c21,
            0x8ac9: 0x7de9,
            0x8aca: 0x7f36,
            0x8acb: 0x7ff0,
            0x8acc: 0x809d,
            0x8acd: 0x8266,
            0x8ace: 0x839e,
            0x8acf: 0x89b3,
            0x8ad0: 0x8acc,
            0x8ad1: 0x8cab,
            0x8ad2: 0x9084,
            0x8ad3: 0x9451,
            0x8ad4: 0x9593,
            0x8ad5: 0x9591,
            0x8ad6: 0x95a2,
            0x8ad7: 0x9665,
            0x8ad8: 0x97d3,
            0x8ad9: 0x9928,
            0x8ada: 0x8218,
            0x8adb: 0x4e38,
            0x8adc: 0x542b,
            0x8add: 0x5cb8,
            0x8ade: 0x5dcc,
            0x8adf: 0x73a9,
            0x8ae0: 0x764c,
            0x8ae1: 0x773c,
            0x8ae2: 0x5ca9,
            0x8ae3: 0x7feb,
            0x8ae4: 0x8d0b,
            0x8ae5: 0x96c1,
            0x8ae6: 0x9811,
            0x8ae7: 0x9854,
            0x8ae8: 0x9858,
            0x8ae9: 0x4f01,
            0x8aea: 0x4f0e,
            0x8aeb: 0x5371,
            0x8aec: 0x559c,
            0x8aed: 0x5668,
            0x8aee: 0x57fa,
            0x8aef: 0x5947,
            0x8af0: 0x5b09,
            0x8af1: 0x5bc4,
            0x8af2: 0x5c90,
            0x8af3: 0x5e0c,
            0x8af4: 0x5e7e,
            0x8af5: 0x5fcc,
            0x8af6: 0x63ee,
            0x8af7: 0x673a,
            0x8af8: 0x65d7,
            0x8af9: 0x65e2,
            0x8afa: 0x671f,
            0x8afb: 0x68cb,
            0x8afc: 0x68c4,
            0x8b40: 0x6a5f,
            0x8b41: 0x5e30,
            0x8b42: 0x6bc5,
            0x8b43: 0x6c17,
            0x8b44: 0x6c7d,
            0x8b45: 0x757f,
            0x8b46: 0x7948,
            0x8b47: 0x5b63,
            0x8b48: 0x7a00,
            0x8b49: 0x7d00,
            0x8b4a: 0x5fbd,
            0x8b4b: 0x898f,
            0x8b4c: 0x8a18,
            0x8b4d: 0x8cb4,
            0x8b4e: 0x8d77,
            0x8b4f: 0x8ecc,
            0x8b50: 0x8f1d,
            0x8b51: 0x98e2,
            0x8b52: 0x9a0e,
            0x8b53: 0x9b3c,
            0x8b54: 0x4e80,
            0x8b55: 0x507d,
            0x8b56: 0x5100,
            0x8b57: 0x5993,
            0x8b58: 0x5b9c,
            0x8b59: 0x622f,
            0x8b5a: 0x6280,
            0x8b5b: 0x64ec,
            0x8b5c: 0x6b3a,
            0x8b5d: 0x72a0,
            0x8b5e: 0x7591,
            0x8b5f: 0x7947,
            0x8b60: 0x7fa9,
            0x8b61: 0x87fb,
            0x8b62: 0x8abc,
            0x8b63: 0x8b70,
            0x8b64: 0x63ac,
            0x8b65: 0x83ca,
            0x8b66: 0x97a0,
            0x8b67: 0x5409,
            0x8b68: 0x5403,
            0x8b69: 0x55ab,
            0x8b6a: 0x6854,
            0x8b6b: 0x6a58,
            0x8b6c: 0x8a70,
            0x8b6d: 0x7827,
            0x8b6e: 0x6775,
            0x8b6f: 0x9ecd,
            0x8b70: 0x5374,
            0x8b71: 0x5ba2,
            0x8b72: 0x811a,
            0x8b73: 0x8650,
            0x8b74: 0x9006,
            0x8b75: 0x4e18,
            0x8b76: 0x4e45,
            0x8b77: 0x4ec7,
            0x8b78: 0x4f11,
            0x8b79: 0x53ca,
            0x8b7a: 0x5438,
            0x8b7b: 0x5bae,
            0x8b7c: 0x5f13,
            0x8b7d: 0x6025,
            0x8b7e: 0x6551,
            0x8b80: 0x673d,
            0x8b81: 0x6c42,
            0x8b82: 0x6c72,
            0x8b83: 0x6ce3,
            0x8b84: 0x7078,
            0x8b85: 0x7403,
            0x8b86: 0x7a76,
            0x8b87: 0x7aae,
            0x8b88: 0x7b08,
            0x8b89: 0x7d1a,
            0x8b8a: 0x7cfe,
            0x8b8b: 0x7d66,
            0x8b8c: 0x65e7,
            0x8b8d: 0x725b,
            0x8b8e: 0x53bb,
            0x8b8f: 0x5c45,
            0x8b90: 0x5de8,
            0x8b91: 0x62d2,
            0x8b92: 0x62e0,
            0x8b93: 0x6319,
            0x8b94: 0x6e20,
            0x8b95: 0x865a,
            0x8b96: 0x8a31,
            0x8b97: 0x8ddd,
            0x8b98: 0x92f8,
            0x8b99: 0x6f01,
            0x8b9a: 0x79a6,
            0x8b9b: 0x9b5a,
            0x8b9c: 0x4ea8,
            0x8b9d: 0x4eab,
            0x8b9e: 0x4eac,
            0x8b9f: 0x4f9b,
            0x8ba0: 0x4fa0,
            0x8ba1: 0x50d1,
            0x8ba2: 0x5147,
            0x8ba3: 0x7af6,
            0x8ba4: 0x5171,
            0x8ba5: 0x51f6,
            0x8ba6: 0x5354,
            0x8ba7: 0x5321,
            0x8ba8: 0x537f,
            0x8ba9: 0x53eb,
            0x8baa: 0x55ac,
            0x8bab: 0x5883,
            0x8bac: 0x5ce1,
            0x8bad: 0x5f37,
            0x8bae: 0x5f4a,
            0x8baf: 0x602f,
            0x8bb0: 0x6050,
            0x8bb1: 0x606d,
            0x8bb2: 0x631f,
            0x8bb3: 0x6559,
            0x8bb4: 0x6a4b,
            0x8bb5: 0x6cc1,
            0x8bb6: 0x72c2,
            0x8bb7: 0x72ed,
            0x8bb8: 0x77ef,
            0x8bb9: 0x80f8,
            0x8bba: 0x8105,
            0x8bbb: 0x8208,
            0x8bbc: 0x854e,
            0x8bbd: 0x90f7,
            0x8bbe: 0x93e1,
            0x8bbf: 0x97ff,
            0x8bc0: 0x9957,
            0x8bc1: 0x9a5a,
            0x8bc2: 0x4ef0,
            0x8bc3: 0x51dd,
            0x8bc4: 0x5c2d,
            0x8bc5: 0x6681,
            0x8bc6: 0x696d,
            0x8bc7: 0x5c40,
            0x8bc8: 0x66f2,
            0x8bc9: 0x6975,
            0x8bca: 0x7389,
            0x8bcb: 0x6850,
            0x8bcc: 0x7c81,
            0x8bcd: 0x50c5,
            0x8bce: 0x52e4,
            0x8bcf: 0x5747,
            0x8bd0: 0x5dfe,
            0x8bd1: 0x9326,
            0x8bd2: 0x65a4,
            0x8bd3: 0x6b23,
            0x8bd4: 0x6b3d,
            0x8bd5: 0x7434,
            0x8bd6: 0x7981,
            0x8bd7: 0x79bd,
            0x8bd8: 0x7b4b,
            0x8bd9: 0x7dca,
            0x8bda: 0x82b9,
            0x8bdb: 0x83cc,
            0x8bdc: 0x887f,
            0x8bdd: 0x895f,
            0x8bde: 0x8b39,
            0x8bdf: 0x8fd1,
            0x8be0: 0x91d1,
            0x8be1: 0x541f,
            0x8be2: 0x9280,
            0x8be3: 0x4e5d,
            0x8be4: 0x5036,
            0x8be5: 0x53e5,
            0x8be6: 0x533a,
            0x8be7: 0x72d7,
            0x8be8: 0x7396,
            0x8be9: 0x77e9,
            0x8bea: 0x82e6,
            0x8beb: 0x8eaf,
            0x8bec: 0x99c6,
            0x8bed: 0x99c8,
            0x8bee: 0x99d2,
            0x8bef: 0x5177,
            0x8bf0: 0x611a,
            0x8bf1: 0x865e,
            0x8bf2: 0x55b0,
            0x8bf3: 0x7a7a,
            0x8bf4: 0x5076,
            0x8bf5: 0x5bd3,
            0x8bf6: 0x9047,
            0x8bf7: 0x9685,
            0x8bf8: 0x4e32,
            0x8bf9: 0x6adb,
            0x8bfa: 0x91e7,
            0x8bfb: 0x5c51,
            0x8bfc: 0x5c48,
            0x8c40: 0x6398,
            0x8c41: 0x7a9f,
            0x8c42: 0x6c93,
            0x8c43: 0x9774,
            0x8c44: 0x8f61,
            0x8c45: 0x7aaa,
            0x8c46: 0x718a,
            0x8c47: 0x9688,
            0x8c48: 0x7c82,
            0x8c49: 0x6817,
            0x8c4a: 0x7e70,
            0x8c4b: 0x6851,
            0x8c4c: 0x936c,
            0x8c4d: 0x52f2,
            0x8c4e: 0x541b,
            0x8c4f: 0x85ab,
            0x8c50: 0x8a13,
            0x8c51: 0x7fa4,
            0x8c52: 0x8ecd,
            0x8c53: 0x90e1,
            0x8c54: 0x5366,
            0x8c55: 0x8888,
            0x8c56: 0x7941,
            0x8c57: 0x4fc2,
            0x8c58: 0x50be,
            0x8c59: 0x5211,
            0x8c5a: 0x5144,
            0x8c5b: 0x5553,
            0x8c5c: 0x572d,
            0x8c5d: 0x73ea,
            0x8c5e: 0x578b,
            0x8c5f: 0x5951,
            0x8c60: 0x5f62,
            0x8c61: 0x5f84,
            0x8c62: 0x6075,
            0x8c63: 0x6176,
            0x8c64: 0x6167,
            0x8c65: 0x61a9,
            0x8c66: 0x63b2,
            0x8c67: 0x643a,
            0x8c68: 0x656c,
            0x8c69: 0x666f,
            0x8c6a: 0x6842,
            0x8c6b: 0x6e13,
            0x8c6c: 0x7566,
            0x8c6d: 0x7a3d,
            0x8c6e: 0x7cfb,
            0x8c6f: 0x7d4c,
            0x8c70: 0x7d99,
            0x8c71: 0x7e4b,
            0x8c72: 0x7f6b,
            0x8c73: 0x830e,
            0x8c74: 0x834a,
            0x8c75: 0x86cd,
            0x8c76: 0x8a08,
            0x8c77: 0x8a63,
            0x8c78: 0x8b66,
            0x8c79: 0x8efd,
            0x8c7a: 0x981a,
            0x8c7b: 0x9d8f,
            0x8c7c: 0x82b8,
            0x8c7d: 0x8fce,
            0x8c7e: 0x9be8,
            0x8c80: 0x5287,
            0x8c81: 0x621f,
            0x8c82: 0x6483,
            0x8c83: 0x6fc0,
            0x8c84: 0x9699,
            0x8c85: 0x6841,
            0x8c86: 0x5091,
            0x8c87: 0x6b20,
            0x8c88: 0x6c7a,
            0x8c89: 0x6f54,
            0x8c8a: 0x7a74,
            0x8c8b: 0x7d50,
            0x8c8c: 0x8840,
            0x8c8d: 0x8a23,
            0x8c8e: 0x6708,
            0x8c8f: 0x4ef6,
            0x8c90: 0x5039,
            0x8c91: 0x5026,
            0x8c92: 0x5065,
            0x8c93: 0x517c,
            0x8c94: 0x5238,
            0x8c95: 0x5263,
            0x8c96: 0x55a7,
            0x8c97: 0x570f,
            0x8c98: 0x5805,
            0x8c99: 0x5acc,
            0x8c9a: 0x5efa,
            0x8c9b: 0x61b2,
            0x8c9c: 0x61f8,
            0x8c9d: 0x62f3,
            0x8c9e: 0x6372,
            0x8c9f: 0x691c,
            0x8ca0: 0x6a29,
            0x8ca1: 0x727d,
            0x8ca2: 0x72ac,
            0x8ca3: 0x732e,
            0x8ca4: 0x7814,
            0x8ca5: 0x786f,
            0x8ca6: 0x7d79,
            0x8ca7: 0x770c,
            0x8ca8: 0x80a9,
            0x8ca9: 0x898b,
            0x8caa: 0x8b19,
            0x8cab: 0x8ce2,
            0x8cac: 0x8ed2,
            0x8cad: 0x9063,
            0x8cae: 0x9375,
            0x8caf: 0x967a,
            0x8cb0: 0x9855,
            0x8cb1: 0x9a13,
            0x8cb2: 0x9e78,
            0x8cb3: 0x5143,
            0x8cb4: 0x539f,
            0x8cb5: 0x53b3,
            0x8cb6: 0x5e7b,
            0x8cb7: 0x5f26,
            0x8cb8: 0x6e1b,
            0x8cb9: 0x6e90,
            0x8cba: 0x7384,
            0x8cbb: 0x73fe,
            0x8cbc: 0x7d43,
            0x8cbd: 0x8237,
            0x8cbe: 0x8a00,
            0x8cbf: 0x8afa,
            0x8cc0: 0x9650,
            0x8cc1: 0x4e4e,
            0x8cc2: 0x500b,
            0x8cc3: 0x53e4,
            0x8cc4: 0x547c,
            0x8cc5: 0x56fa,
            0x8cc6: 0x59d1,
            0x8cc7: 0x5b64,
            0x8cc8: 0x5df1,
            0x8cc9: 0x5eab,
            0x8cca: 0x5f27,
            0x8ccb: 0x6238,
            0x8ccc: 0x6545,
            0x8ccd: 0x67af,
            0x8cce: 0x6e56,
            0x8ccf: 0x72d0,
            0x8cd0: 0x7cca,
            0x8cd1: 0x88b4,
            0x8cd2: 0x80a1,
            0x8cd3: 0x80e1,
            0x8cd4: 0x83f0,
            0x8cd5: 0x864e,
            0x8cd6: 0x8a87,
            0x8cd7: 0x8de8,
            0x8cd8: 0x9237,
            0x8cd9: 0x96c7,
            0x8cda: 0x9867,
            0x8cdb: 0x9f13,
            0x8cdc: 0x4e94,
            0x8cdd: 0x4e92,
            0x8cde: 0x4f0d,
            0x8cdf: 0x5348,
            0x8ce0: 0x5449,
            0x8ce1: 0x543e,
            0x8ce2: 0x5a2f,
            0x8ce3: 0x5f8c,
            0x8ce4: 0x5fa1,
            0x8ce5: 0x609f,
            0x8ce6: 0x68a7,
            0x8ce7: 0x6a8e,
            0x8ce8: 0x745a,
            0x8ce9: 0x7881,
            0x8cea: 0x8a9e,
            0x8ceb: 0x8aa4,
            0x8cec: 0x8b77,
            0x8ced: 0x9190,
            0x8cee: 0x4e5e,
            0x8cef: 0x9bc9,
            0x8cf0: 0x4ea4,
            0x8cf1: 0x4f7c,
            0x8cf2: 0x4faf,
            0x8cf3: 0x5019,
            0x8cf4: 0x5016,
            0x8cf5: 0x5149,
            0x8cf6: 0x516c,
            0x8cf7: 0x529f,
            0x8cf8: 0x52b9,
            0x8cf9: 0x52fe,
            0x8cfa: 0x539a,
            0x8cfb: 0x53e3,
            0x8cfc: 0x5411,
            0x8d40: 0x540e,
            0x8d41: 0x5589,
            0x8d42: 0x5751,
            0x8d43: 0x57a2,
            0x8d44: 0x597d,
            0x8d45: 0x5b54,
            0x8d46: 0x5b5d,
            0x8d47: 0x5b8f,
            0x8d48: 0x5de5,
            0x8d49: 0x5de7,
            0x8d4a: 0x5df7,
            0x8d4b: 0x5e78,
            0x8d4c: 0x5e83,
            0x8d4d: 0x5e9a,
            0x8d4e: 0x5eb7,
            0x8d4f: 0x5f18,
            0x8d50: 0x6052,
            0x8d51: 0x614c,
            0x8d52: 0x6297,
            0x8d53: 0x62d8,
            0x8d54: 0x63a7,
            0x8d55: 0x653b,
            0x8d56: 0x6602,
            0x8d57: 0x6643,
            0x8d58: 0x66f4,
            0x8d59: 0x676d,
            0x8d5a: 0x6821,
            0x8d5b: 0x6897,
            0x8d5c: 0x69cb,
            0x8d5d: 0x6c5f,
            0x8d5e: 0x6d2a,
            0x8d5f: 0x6d69,
            0x8d60: 0x6e2f,
            0x8d61: 0x6e9d,
            0x8d62: 0x7532,
            0x8d63: 0x7687,
            0x8d64: 0x786c,
            0x8d65: 0x7a3f,
            0x8d66: 0x7ce0,
            0x8d67: 0x7d05,
            0x8d68: 0x7d18,
            0x8d69: 0x7d5e,
            0x8d6a: 0x7db1,
            0x8d6b: 0x8015,
            0x8d6c: 0x8003,
            0x8d6d: 0x80af,
            0x8d6e: 0x80b1,
            0x8d6f: 0x8154,
            0x8d70: 0x818f,
            0x8d71: 0x822a,
            0x8d72: 0x8352,
            0x8d73: 0x884c,
            0x8d74: 0x8861,
            0x8d75: 0x8b1b,
            0x8d76: 0x8ca2,
            0x8d77: 0x8cfc,
            0x8d78: 0x90ca,
            0x8d79: 0x9175,
            0x8d7a: 0x9271,
            0x8d7b: 0x783f,
            0x8d7c: 0x92fc,
            0x8d7d: 0x95a4,
            0x8d7e: 0x964d,
            0x8d80: 0x9805,
            0x8d81: 0x9999,
            0x8d82: 0x9ad8,
            0x8d83: 0x9d3b,
            0x8d84: 0x525b,
            0x8d85: 0x52ab,
            0x8d86: 0x53f7,
            0x8d87: 0x5408,
            0x8d88: 0x58d5,
            0x8d89: 0x62f7,
            0x8d8a: 0x6fe0,
            0x8d8b: 0x8c6a,
            0x8d8c: 0x8f5f,
            0x8d8d: 0x9eb9,
            0x8d8e: 0x514b,
            0x8d8f: 0x523b,
            0x8d90: 0x544a,
            0x8d91: 0x56fd,
            0x8d92: 0x7a40,
            0x8d93: 0x9177,
            0x8d94: 0x9d60,
            0x8d95: 0x9ed2,
            0x8d96: 0x7344,
            0x8d97: 0x6f09,
            0x8d98: 0x8170,
            0x8d99: 0x7511,
            0x8d9a: 0x5ffd,
            0x8d9b: 0x60da,
            0x8d9c: 0x9aa8,
            0x8d9d: 0x72db,
            0x8d9e: 0x8fbc,
            0x8d9f: 0x6b64,
            0x8da0: 0x9803,
            0x8da1: 0x4eca,
            0x8da2: 0x56f0,
            0x8da3: 0x5764,
            0x8da4: 0x58be,
            0x8da5: 0x5a5a,
            0x8da6: 0x6068,
            0x8da7: 0x61c7,
            0x8da8: 0x660f,
            0x8da9: 0x6606,
            0x8daa: 0x6839,
            0x8dab: 0x68b1,
            0x8dac: 0x6df7,
            0x8dad: 0x75d5,
            0x8dae: 0x7d3a,
            0x8daf: 0x826e,
            0x8db0: 0x9b42,
            0x8db1: 0x4e9b,
            0x8db2: 0x4f50,
            0x8db3: 0x53c9,
            0x8db4: 0x5506,
            0x8db5: 0x5d6f,
            0x8db6: 0x5de6,
            0x8db7: 0x5dee,
            0x8db8: 0x67fb,
            0x8db9: 0x6c99,
            0x8dba: 0x7473,
            0x8dbb: 0x7802,
            0x8dbc: 0x8a50,
            0x8dbd: 0x9396,
            0x8dbe: 0x88df,
            0x8dbf: 0x5750,
            0x8dc0: 0x5ea7,
            0x8dc1: 0x632b,
            0x8dc2: 0x50b5,
            0x8dc3: 0x50ac,
            0x8dc4: 0x518d,
            0x8dc5: 0x6700,
            0x8dc6: 0x54c9,
            0x8dc7: 0x585e,
            0x8dc8: 0x59bb,
            0x8dc9: 0x5bb0,
            0x8dca: 0x5f69,
            0x8dcb: 0x624d,
            0x8dcc: 0x63a1,
            0x8dcd: 0x683d,
            0x8dce: 0x6b73,
            0x8dcf: 0x6e08,
            0x8dd0: 0x707d,
            0x8dd1: 0x91c7,
            0x8dd2: 0x7280,
            0x8dd3: 0x7815,
            0x8dd4: 0x7826,
            0x8dd5: 0x796d,
            0x8dd6: 0x658e,
            0x8dd7: 0x7d30,
            0x8dd8: 0x83dc,
            0x8dd9: 0x88c1,
            0x8dda: 0x8f09,
            0x8ddb: 0x969b,
            0x8ddc: 0x5264,
            0x8ddd: 0x5728,
            0x8dde: 0x6750,
            0x8ddf: 0x7f6a,
            0x8de0: 0x8ca1,
            0x8de1: 0x51b4,
            0x8de2: 0x5742,
            0x8de3: 0x962a,
            0x8de4: 0x583a,
            0x8de5: 0x698a,
            0x8de6: 0x80b4,
            0x8de7: 0x54b2,
            0x8de8: 0x5d0e,
            0x8de9: 0x57fc,
            0x8dea: 0x7895,
            0x8deb: 0x9dfa,
            0x8dec: 0x4f5c,
            0x8ded: 0x524a,
            0x8dee: 0x548b,
            0x8def: 0x643e,
            0x8df0: 0x6628,
            0x8df1: 0x6714,
            0x8df2: 0x67f5,
            0x8df3: 0x7a84,
            0x8df4: 0x7b56,
            0x8df5: 0x7d22,
            0x8df6: 0x932f,
            0x8df7: 0x685c,
            0x8df8: 0x9bad,
            0x8df9: 0x7b39,
            0x8dfa: 0x5319,
            0x8dfb: 0x518a,
            0x8dfc: 0x5237,
            0x8e40: 0x5bdf,
            0x8e41: 0x62f6,
            0x8e42: 0x64ae,
            0x8e43: 0x64e6,
            0x8e44: 0x672d,
            0x8e45: 0x6bba,
            0x8e46: 0x85a9,
            0x8e47: 0x96d1,
            0x8e48: 0x7690,
            0x8e49: 0x9bd6,
            0x8e4a: 0x634c,
            0x8e4b: 0x9306,
            0x8e4c: 0x9bab,
            0x8e4d: 0x76bf,
            0x8e4e: 0x6652,
            0x8e4f: 0x4e09,
            0x8e50: 0x5098,
            0x8e51: 0x53c2,
            0x8e52: 0x5c71,
            0x8e53: 0x60e8,
            0x8e54: 0x6492,
            0x8e55: 0x6563,
            0x8e56: 0x685f,
            0x8e57: 0x71e6,
            0x8e58: 0x73ca,
            0x8e59: 0x7523,
            0x8e5a: 0x7b97,
            0x8e5b: 0x7e82,
            0x8e5c: 0x8695,
            0x8e5d: 0x8b83,
            0x8e5e: 0x8cdb,
            0x8e5f: 0x9178,
            0x8e60: 0x9910,
            0x8e61: 0x65ac,
            0x8e62: 0x66ab,
            0x8e63: 0x6b8b,
            0x8e64: 0x4ed5,
            0x8e65: 0x4ed4,
            0x8e66: 0x4f3a,
            0x8e67: 0x4f7f,
            0x8e68: 0x523a,
            0x8e69: 0x53f8,
            0x8e6a: 0x53f2,
            0x8e6b: 0x55e3,
            0x8e6c: 0x56db,
            0x8e6d: 0x58eb,
            0x8e6e: 0x59cb,
            0x8e6f: 0x59c9,
            0x8e70: 0x59ff,
            0x8e71: 0x5b50,
            0x8e72: 0x5c4d,
            0x8e73: 0x5e02,
            0x8e74: 0x5e2b,
            0x8e75: 0x5fd7,
            0x8e76: 0x601d,
            0x8e77: 0x6307,
            0x8e78: 0x652f,
            0x8e79: 0x5b5c,
            0x8e7a: 0x65af,
            0x8e7b: 0x65bd,
            0x8e7c: 0x65e8,
            0x8e7d: 0x679d,
            0x8e7e: 0x6b62,
            0x8e80: 0x6b7b,
            0x8e81: 0x6c0f,
            0x8e82: 0x7345,
            0x8e83: 0x7949,
            0x8e84: 0x79c1,
            0x8e85: 0x7cf8,
            0x8e86: 0x7d19,
            0x8e87: 0x7d2b,
            0x8e88: 0x80a2,
            0x8e89: 0x8102,
            0x8e8a: 0x81f3,
            0x8e8b: 0x8996,
            0x8e8c: 0x8a5e,
            0x8e8d: 0x8a69,
            0x8e8e: 0x8a66,
            0x8e8f: 0x8a8c,
            0x8e90: 0x8aee,
            0x8e91: 0x8cc7,
            0x8e92: 0x8cdc,
            0x8e93: 0x96cc,
            0x8e94: 0x98fc,
            0x8e95: 0x6b6f,
            0x8e96: 0x4e8b,
            0x8e97: 0x4f3c,
            0x8e98: 0x4f8d,
            0x8e99: 0x5150,
            0x8e9a: 0x5b57,
            0x8e9b: 0x5bfa,
            0x8e9c: 0x6148,
            0x8e9d: 0x6301,
            0x8e9e: 0x6642,
            0x8e9f: 0x6b21,
            0x8ea0: 0x6ecb,
            0x8ea1: 0x6cbb,
            0x8ea2: 0x723e,
            0x8ea3: 0x74bd,
            0x8ea4: 0x75d4,
            0x8ea5: 0x78c1,
            0x8ea6: 0x793a,
            0x8ea7: 0x800c,
            0x8ea8: 0x8033,
            0x8ea9: 0x81ea,
            0x8eaa: 0x8494,
            0x8eab: 0x8f9e,
            0x8eac: 0x6c50,
            0x8ead: 0x9e7f,
            0x8eae: 0x5f0f,
            0x8eaf: 0x8b58,
            0x8eb0: 0x9d2b,
            0x8eb1: 0x7afa,
            0x8eb2: 0x8ef8,
            0x8eb3: 0x5b8d,
            0x8eb4: 0x96eb,
            0x8eb5: 0x4e03,
            0x8eb6: 0x53f1,
            0x8eb7: 0x57f7,
            0x8eb8: 0x5931,
            0x8eb9: 0x5ac9,
            0x8eba: 0x5ba4,
            0x8ebb: 0x6089,
            0x8ebc: 0x6e7f,
            0x8ebd: 0x6f06,
            0x8ebe: 0x75be,
            0x8ebf: 0x8cea,
            0x8ec0: 0x5b9f,
            0x8ec1: 0x8500,
            0x8ec2: 0x7be0,
            0x8ec3: 0x5072,
            0x8ec4: 0x67f4,
            0x8ec5: 0x829d,
            0x8ec6: 0x5c61,
            0x8ec7: 0x854a,
            0x8ec8: 0x7e1e,
            0x8ec9: 0x820e,
            0x8eca: 0x5199,
            0x8ecb: 0x5c04,
            0x8ecc: 0x6368,
            0x8ecd: 0x8d66,
            0x8ece: 0x659c,
            0x8ecf: 0x716e,
            0x8ed0: 0x793e,
            0x8ed1: 0x7d17,
            0x8ed2: 0x8005,
            0x8ed3: 0x8b1d,
            0x8ed4: 0x8eca,
            0x8ed5: 0x906e,
            0x8ed6: 0x86c7,
            0x8ed7: 0x90aa,
            0x8ed8: 0x501f,
            0x8ed9: 0x52fa,
            0x8eda: 0x5c3a,
            0x8edb: 0x6753,
            0x8edc: 0x707c,
            0x8edd: 0x7235,
            0x8ede: 0x914c,
            0x8edf: 0x91c8,
            0x8ee0: 0x932b,
            0x8ee1: 0x82e5,
            0x8ee2: 0x5bc2,
            0x8ee3: 0x5f31,
            0x8ee4: 0x60f9,
            0x8ee5: 0x4e3b,
            0x8ee6: 0x53d6,
            0x8ee7: 0x5b88,
            0x8ee8: 0x624b,
            0x8ee9: 0x6731,
            0x8eea: 0x6b8a,
            0x8eeb: 0x72e9,
            0x8eec: 0x73e0,
            0x8eed: 0x7a2e,
            0x8eee: 0x816b,
            0x8eef: 0x8da3,
            0x8ef0: 0x9152,
            0x8ef1: 0x9996,
            0x8ef2: 0x5112,
            0x8ef3: 0x53d7,
            0x8ef4: 0x546a,
            0x8ef5: 0x5bff,
            0x8ef6: 0x6388,
            0x8ef7: 0x6a39,
            0x8ef8: 0x7dac,
            0x8ef9: 0x9700,
            0x8efa: 0x56da,
            0x8efb: 0x53ce,
            0x8efc: 0x5468,
            0x8f40: 0x5b97,
            0x8f41: 0x5c31,
            0x8f42: 0x5dde,
            0x8f43: 0x4fee,
            0x8f44: 0x6101,
            0x8f45: 0x62fe,
            0x8f46: 0x6d32,
            0x8f47: 0x79c0,
            0x8f48: 0x79cb,
            0x8f49: 0x7d42,
            0x8f4a: 0x7e4d,
            0x8f4b: 0x7fd2,
            0x8f4c: 0x81ed,
            0x8f4d: 0x821f,
            0x8f4e: 0x8490,
            0x8f4f: 0x8846,
            0x8f50: 0x8972,
            0x8f51: 0x8b90,
            0x8f52: 0x8e74,
            0x8f53: 0x8f2f,
            0x8f54: 0x9031,
            0x8f55: 0x914b,
            0x8f56: 0x916c,
            0x8f57: 0x96c6,
            0x8f58: 0x919c,
            0x8f59: 0x4ec0,
            0x8f5a: 0x4f4f,
            0x8f5b: 0x5145,
            0x8f5c: 0x5341,
            0x8f5d: 0x5f93,
            0x8f5e: 0x620e,
            0x8f5f: 0x67d4,
            0x8f60: 0x6c41,
            0x8f61: 0x6e0b,
            0x8f62: 0x7363,
            0x8f63: 0x7e26,
            0x8f64: 0x91cd,
            0x8f65: 0x9283,
            0x8f66: 0x53d4,
            0x8f67: 0x5919,
            0x8f68: 0x5bbf,
            0x8f69: 0x6dd1,
            0x8f6a: 0x795d,
            0x8f6b: 0x7e2e,
            0x8f6c: 0x7c9b,
            0x8f6d: 0x587e,
            0x8f6e: 0x719f,
            0x8f6f: 0x51fa,
            0x8f70: 0x8853,
            0x8f71: 0x8ff0,
            0x8f72: 0x4fca,
            0x8f73: 0x5cfb,
            0x8f74: 0x6625,
            0x8f75: 0x77ac,
            0x8f76: 0x7ae3,
            0x8f77: 0x821c,
            0x8f78: 0x99ff,
            0x8f79: 0x51c6,
            0x8f7a: 0x5faa,
            0x8f7b: 0x65ec,
            0x8f7c: 0x696f,
            0x8f7d: 0x6b89,
            0x8f7e: 0x6df3,
            0x8f80: 0x6e96,
            0x8f81: 0x6f64,
            0x8f82: 0x76fe,
            0x8f83: 0x7d14,
            0x8f84: 0x5de1,
            0x8f85: 0x9075,
            0x8f86: 0x9187,
            0x8f87: 0x9806,
            0x8f88: 0x51e6,
            0x8f89: 0x521d,
            0x8f8a: 0x6240,
            0x8f8b: 0x6691,
            0x8f8c: 0x66d9,
            0x8f8d: 0x6e1a,
            0x8f8e: 0x5eb6,
            0x8f8f: 0x7dd2,
            0x8f90: 0x7f72,
            0x8f91: 0x66f8,
            0x8f92: 0x85af,
            0x8f93: 0x85f7,
            0x8f94: 0x8af8,
            0x8f95: 0x52a9,
            0x8f96: 0x53d9,
            0x8f97: 0x5973,
            0x8f98: 0x5e8f,
            0x8f99: 0x5f90,
            0x8f9a: 0x6055,
            0x8f9b: 0x92e4,
            0x8f9c: 0x9664,
            0x8f9d: 0x50b7,
            0x8f9e: 0x511f,
            0x8f9f: 0x52dd,
            0x8fa0: 0x5320,
            0x8fa1: 0x5347,
            0x8fa2: 0x53ec,
            0x8fa3: 0x54e8,
            0x8fa4: 0x5546,
            0x8fa5: 0x5531,
            0x8fa6: 0x5617,
            0x8fa7: 0x5968,
            0x8fa8: 0x59be,
            0x8fa9: 0x5a3c,
            0x8faa: 0x5bb5,
            0x8fab: 0x5c06,
            0x8fac: 0x5c0f,
            0x8fad: 0x5c11,
            0x8fae: 0x5c1a,
            0x8faf: 0x5e84,
            0x8fb0: 0x5e8a,
            0x8fb1: 0x5ee0,
            0x8fb2: 0x5f70,
            0x8fb3: 0x627f,
            0x8fb4: 0x6284,
            0x8fb5: 0x62db,
            0x8fb6: 0x638c,
            0x8fb7: 0x6377,
            0x8fb8: 0x6607,
            0x8fb9: 0x660c,
            0x8fba: 0x662d,
            0x8fbb: 0x6676,
            0x8fbc: 0x677e,
            0x8fbd: 0x68a2,
            0x8fbe: 0x6a1f,
            0x8fbf: 0x6a35,
            0x8fc0: 0x6cbc,
            0x8fc1: 0x6d88,
            0x8fc2: 0x6e09,
            0x8fc3: 0x6e58,
            0x8fc4: 0x713c,
            0x8fc5: 0x7126,
            0x8fc6: 0x7167,
            0x8fc7: 0x75c7,
            0x8fc8: 0x7701,
            0x8fc9: 0x785d,
            0x8fca: 0x7901,
            0x8fcb: 0x7965,
            0x8fcc: 0x79f0,
            0x8fcd: 0x7ae0,
            0x8fce: 0x7b11,
            0x8fcf: 0x7ca7,
            0x8fd0: 0x7d39,
            0x8fd1: 0x8096,
            0x8fd2: 0x83d6,
            0x8fd3: 0x848b,
            0x8fd4: 0x8549,
            0x8fd5: 0x885d,
            0x8fd6: 0x88f3,
            0x8fd7: 0x8a1f,
            0x8fd8: 0x8a3c,
            0x8fd9: 0x8a54,
            0x8fda: 0x8a73,
            0x8fdb: 0x8c61,
            0x8fdc: 0x8cde,
            0x8fdd: 0x91a4,
            0x8fde: 0x9266,
            0x8fdf: 0x937e,
            0x8fe0: 0x9418,
            0x8fe1: 0x969c,
            0x8fe2: 0x9798,
            0x8fe3: 0x4e0a,
            0x8fe4: 0x4e08,
            0x8fe5: 0x4e1e,
            0x8fe6: 0x4e57,
            0x8fe7: 0x5197,
            0x8fe8: 0x5270,
            0x8fe9: 0x57ce,
            0x8fea: 0x5834,
            0x8feb: 0x58cc,
            0x8fec: 0x5b22,
            0x8fed: 0x5e38,
            0x8fee: 0x60c5,
            0x8fef: 0x64fe,
            0x8ff0: 0x6761,
            0x8ff1: 0x6756,
            0x8ff2: 0x6d44,
            0x8ff3: 0x72b6,
            0x8ff4: 0x7573,
            0x8ff5: 0x7a63,
            0x8ff6: 0x84b8,
            0x8ff7: 0x8b72,
            0x8ff8: 0x91b8,
            0x8ff9: 0x9320,
            0x8ffa: 0x5631,
            0x8ffb: 0x57f4,
            0x8ffc: 0x98fe,
            0x9040: 0x62ed,
            0x9041: 0x690d,
            0x9042: 0x6b96,
            0x9043: 0x71ed,
            0x9044: 0x7e54,
            0x9045: 0x8077,
            0x9046: 0x8272,
            0x9047: 0x89e6,
            0x9048: 0x98df,
            0x9049: 0x8755,
            0x904a: 0x8fb1,
            0x904b: 0x5c3b,
            0x904c: 0x4f38,
            0x904d: 0x4fe1,
            0x904e: 0x4fb5,
            0x904f: 0x5507,
            0x9050: 0x5a20,
            0x9051: 0x5bdd,
            0x9052: 0x5be9,
            0x9053: 0x5fc3,
            0x9054: 0x614e,
            0x9055: 0x632f,
            0x9056: 0x65b0,
            0x9057: 0x664b,
            0x9058: 0x68ee,
            0x9059: 0x699b,
            0x905a: 0x6d78,
            0x905b: 0x6df1,
            0x905c: 0x7533,
            0x905d: 0x75b9,
            0x905e: 0x771f,
            0x905f: 0x795e,
            0x9060: 0x79e6,
            0x9061: 0x7d33,
            0x9062: 0x81e3,
            0x9063: 0x82af,
            0x9064: 0x85aa,
            0x9065: 0x89aa,
            0x9066: 0x8a3a,
            0x9067: 0x8eab,
            0x9068: 0x8f9b,
            0x9069: 0x9032,
            0x906a: 0x91dd,
            0x906b: 0x9707,
            0x906c: 0x4eba,
            0x906d: 0x4ec1,
            0x906e: 0x5203,
            0x906f: 0x5875,
            0x9070: 0x58ec,
            0x9071: 0x5c0b,
            0x9072: 0x751a,
            0x9073: 0x5c3d,
            0x9074: 0x814e,
            0x9075: 0x8a0a,
            0x9076: 0x8fc5,
            0x9077: 0x9663,
            0x9078: 0x976d,
            0x9079: 0x7b25,
            0x907a: 0x8acf,
            0x907b: 0x9808,
            0x907c: 0x9162,
            0x907d: 0x56f3,
            0x907e: 0x53a8,
            0x9080: 0x9017,
            0x9081: 0x5439,
            0x9082: 0x5782,
            0x9083: 0x5e25,
            0x9084: 0x63a8,
            0x9085: 0x6c34,
            0x9086: 0x708a,
            0x9087: 0x7761,
            0x9088: 0x7c8b,
            0x9089: 0x7fe0,
            0x908a: 0x8870,
            0x908b: 0x9042,
            0x908c: 0x9154,
            0x908d: 0x9310,
            0x908e: 0x9318,
            0x908f: 0x968f,
            0x9090: 0x745e,
            0x9091: 0x9ac4,
            0x9092: 0x5d07,
            0x9093: 0x5d69,
            0x9094: 0x6570,
            0x9095: 0x67a2,
            0x9096: 0x8da8,
            0x9097: 0x96db,
            0x9098: 0x636e,
            0x9099: 0x6749,
            0x909a: 0x6919,
            0x909b: 0x83c5,
            0x909c: 0x9817,
            0x909d: 0x96c0,
            0x909e: 0x88fe,
            0x909f: 0x6f84,
            0x90a0: 0x647a,
            0x90a1: 0x5bf8,
            0x90a2: 0x4e16,
            0x90a3: 0x702c,
            0x90a4: 0x755d,
            0x90a5: 0x662f,
            0x90a6: 0x51c4,
            0x90a7: 0x5236,
            0x90a8: 0x52e2,
            0x90a9: 0x59d3,
            0x90aa: 0x5f81,
            0x90ab: 0x6027,
            0x90ac: 0x6210,
            0x90ad: 0x653f,
            0x90ae: 0x6574,
            0x90af: 0x661f,
            0x90b0: 0x6674,
            0x90b1: 0x68f2,
            0x90b2: 0x6816,
            0x90b3: 0x6b63,
            0x90b4: 0x6e05,
            0x90b5: 0x7272,
            0x90b6: 0x751f,
            0x90b7: 0x76db,
            0x90b8: 0x7cbe,
            0x90b9: 0x8056,
            0x90ba: 0x58f0,
            0x90bb: 0x88fd,
            0x90bc: 0x897f,
            0x90bd: 0x8aa0,
            0x90be: 0x8a93,
            0x90bf: 0x8acb,
            0x90c0: 0x901d,
            0x90c1: 0x9192,
            0x90c2: 0x9752,
            0x90c3: 0x9759,
            0x90c4: 0x6589,
            0x90c5: 0x7a0e,
            0x90c6: 0x8106,
            0x90c7: 0x96bb,
            0x90c8: 0x5e2d,
            0x90c9: 0x60dc,
            0x90ca: 0x621a,
            0x90cb: 0x65a5,
            0x90cc: 0x6614,
            0x90cd: 0x6790,
            0x90ce: 0x77f3,
            0x90cf: 0x7a4d,
            0x90d0: 0x7c4d,
            0x90d1: 0x7e3e,
            0x90d2: 0x810a,
            0x90d3: 0x8cac,
            0x90d4: 0x8d64,
            0x90d5: 0x8de1,
            0x90d6: 0x8e5f,
            0x90d7: 0x78a9,
            0x90d8: 0x5207,
            0x90d9: 0x62d9,
            0x90da: 0x63a5,
            0x90db: 0x6442,
            0x90dc: 0x6298,
            0x90dd: 0x8a2d,
            0x90de: 0x7a83,
            0x90df: 0x7bc0,
            0x90e0: 0x8aac,
            0x90e1: 0x96ea,
            0x90e2: 0x7d76,
            0x90e3: 0x820c,
            0x90e4: 0x8749,
            0x90e5: 0x4ed9,
            0x90e6: 0x5148,
            0x90e7: 0x5343,
            0x90e8: 0x5360,
            0x90e9: 0x5ba3,
            0x90ea: 0x5c02,
            0x90eb: 0x5c16,
            0x90ec: 0x5ddd,
            0x90ed: 0x6226,
            0x90ee: 0x6247,
            0x90ef: 0x64b0,
            0x90f0: 0x6813,
            0x90f1: 0x6834,
            0x90f2: 0x6cc9,
            0x90f3: 0x6d45,
            0x90f4: 0x6d17,
            0x90f5: 0x67d3,
            0x90f6: 0x6f5c,
            0x90f7: 0x714e,
            0x90f8: 0x717d,
            0x90f9: 0x65cb,
            0x90fa: 0x7a7f,
            0x90fb: 0x7bad,
            0x90fc: 0x7dda,
            0x9140: 0x7e4a,
            0x9141: 0x7fa8,
            0x9142: 0x817a,
            0x9143: 0x821b,
            0x9144: 0x8239,
            0x9145: 0x85a6,
            0x9146: 0x8a6e,
            0x9147: 0x8cce,
            0x9148: 0x8df5,
            0x9149: 0x9078,
            0x914a: 0x9077,
            0x914b: 0x92ad,
            0x914c: 0x9291,
            0x914d: 0x9583,
            0x914e: 0x9bae,
            0x914f: 0x524d,
            0x9150: 0x5584,
            0x9151: 0x6f38,
            0x9152: 0x7136,
            0x9153: 0x5168,
            0x9154: 0x7985,
            0x9155: 0x7e55,
            0x9156: 0x81b3,
            0x9157: 0x7cce,
            0x9158: 0x564c,
            0x9159: 0x5851,
            0x915a: 0x5ca8,
            0x915b: 0x63aa,
            0x915c: 0x66fe,
            0x915d: 0x66fd,
            0x915e: 0x695a,
            0x915f: 0x72d9,
            0x9160: 0x758f,
            0x9161: 0x758e,
            0x9162: 0x790e,
            0x9163: 0x7956,
            0x9164: 0x79df,
            0x9165: 0x7c97,
            0x9166: 0x7d20,
            0x9167: 0x7d44,
            0x9168: 0x8607,
            0x9169: 0x8a34,
            0x916a: 0x963b,
            0x916b: 0x9061,
            0x916c: 0x9f20,
            0x916d: 0x50e7,
            0x916e: 0x5275,
            0x916f: 0x53cc,
            0x9170: 0x53e2,
            0x9171: 0x5009,
            0x9172: 0x55aa,
            0x9173: 0x58ee,
            0x9174: 0x594f,
            0x9175: 0x723d,
            0x9176: 0x5b8b,
            0x9177: 0x5c64,
            0x9178: 0x531d,
            0x9179: 0x60e3,
            0x917a: 0x60f3,
            0x917b: 0x635c,
            0x917c: 0x6383,
            0x917d: 0x633f,
            0x917e: 0x63bb,
            0x9180: 0x64cd,
            0x9181: 0x65e9,
            0x9182: 0x66f9,
            0x9183: 0x5de3,
            0x9184: 0x69cd,
            0x9185: 0x69fd,
            0x9186: 0x6f15,
            0x9187: 0x71e5,
            0x9188: 0x4e89,
            0x9189: 0x75e9,
            0x918a: 0x76f8,
            0x918b: 0x7a93,
            0x918c: 0x7cdf,
            0x918d: 0x7dcf,
            0x918e: 0x7d9c,
            0x918f: 0x8061,
            0x9190: 0x8349,
            0x9191: 0x8358,
            0x9192: 0x846c,
            0x9193: 0x84bc,
            0x9194: 0x85fb,
            0x9195: 0x88c5,
            0x9196: 0x8d70,
            0x9197: 0x9001,
            0x9198: 0x906d,
            0x9199: 0x9397,
            0x919a: 0x971c,
            0x919b: 0x9a12,
            0x919c: 0x50cf,
            0x919d: 0x5897,
            0x919e: 0x618e,
            0x919f: 0x81d3,
            0x91a0: 0x8535,
            0x91a1: 0x8d08,
            0x91a2: 0x9020,
            0x91a3: 0x4fc3,
            0x91a4: 0x5074,
            0x91a5: 0x5247,
            0x91a6: 0x5373,
            0x91a7: 0x606f,
            0x91a8: 0x6349,
            0x91a9: 0x675f,
            0x91aa: 0x6e2c,
            0x91ab: 0x8db3,
            0x91ac: 0x901f,
            0x91ad: 0x4fd7,
            0x91ae: 0x5c5e,
            0x91af: 0x8cca,
            0x91b0: 0x65cf,
            0x91b1: 0x7d9a,
            0x91b2: 0x5352,
            0x91b3: 0x8896,
            0x91b4: 0x5176,
            0x91b5: 0x63c3,
            0x91b6: 0x5b58,
            0x91b7: 0x5b6b,
            0x91b8: 0x5c0a,
            0x91b9: 0x640d,
            0x91ba: 0x6751,
            0x91bb: 0x905c,
            0x91bc: 0x4ed6,
            0x91bd: 0x591a,
            0x91be: 0x592a,
            0x91bf: 0x6c70,
            0x91c0: 0x8a51,
            0x91c1: 0x553e,
            0x91c2: 0x5815,
            0x91c3: 0x59a5,
            0x91c4: 0x60f0,
            0x91c5: 0x6253,
            0x91c6: 0x67c1,
            0x91c7: 0x8235,
            0x91c8: 0x6955,
            0x91c9: 0x9640,
            0x91ca: 0x99c4,
            0x91cb: 0x9a28,
            0x91cc: 0x4f53,
            0x91cd: 0x5806,
            0x91ce: 0x5bfe,
            0x91cf: 0x8010,
            0x91d0: 0x5cb1,
            0x91d1: 0x5e2f,
            0x91d2: 0x5f85,
            0x91d3: 0x6020,
            0x91d4: 0x614b,
            0x91d5: 0x6234,
            0x91d6: 0x66ff,
            0x91d7: 0x6cf0,
            0x91d8: 0x6ede,
            0x91d9: 0x80ce,
            0x91da: 0x817f,
            0x91db: 0x82d4,
            0x91dc: 0x888b,
            0x91dd: 0x8cb8,
            0x91de: 0x9000,
            0x91df: 0x902e,
            0x91e0: 0x968a,
            0x91e1: 0x9edb,
            0x91e2: 0x9bdb,
            0x91e3: 0x4ee3,
            0x91e4: 0x53f0,
            0x91e5: 0x5927,
            0x91e6: 0x7b2c,
            0x91e7: 0x918d,
            0x91e8: 0x984c,
            0x91e9: 0x9df9,
            0x91ea: 0x6edd,
            0x91eb: 0x7027,
            0x91ec: 0x5353,
            0x91ed: 0x5544,
            0x91ee: 0x5b85,
            0x91ef: 0x6258,
            0x91f0: 0x629e,
            0x91f1: 0x62d3,
            0x91f2: 0x6ca2,
            0x91f3: 0x6fef,
            0x91f4: 0x7422,
            0x91f5: 0x8a17,
            0x91f6: 0x9438,
            0x91f7: 0x6fc1,
            0x91f8: 0x8afe,
            0x91f9: 0x8338,
            0x91fa: 0x51e7,
            0x91fb: 0x86f8,
            0x91fc: 0x53ea,
            0x9240: 0x53e9,
            0x9241: 0x4f46,
            0x9242: 0x9054,
            0x9243: 0x8fb0,
            0x9244: 0x596a,
            0x9245: 0x8131,
            0x9246: 0x5dfd,
            0x9247: 0x7aea,
            0x9248: 0x8fbf,
            0x9249: 0x68da,
            0x924a: 0x8c37,
            0x924b: 0x72f8,
            0x924c: 0x9c48,
            0x924d: 0x6a3d,
            0x924e: 0x8ab0,
            0x924f: 0x4e39,
            0x9250: 0x5358,
            0x9251: 0x5606,
            0x9252: 0x5766,
            0x9253: 0x62c5,
            0x9254: 0x63a2,
            0x9255: 0x65e6,
            0x9256: 0x6b4e,
            0x9257: 0x6de1,
            0x9258: 0x6e5b,
            0x9259: 0x70ad,
            0x925a: 0x77ed,
            0x925b: 0x7aef,
            0x925c: 0x7baa,
            0x925d: 0x7dbb,
            0x925e: 0x803d,
            0x925f: 0x80c6,
            0x9260: 0x86cb,
            0x9261: 0x8a95,
            0x9262: 0x935b,
            0x9263: 0x56e3,
            0x9264: 0x58c7,
            0x9265: 0x5f3e,
            0x9266: 0x65ad,
            0x9267: 0x6696,
            0x9268: 0x6a80,
            0x9269: 0x6bb5,
            0x926a: 0x7537,
            0x926b: 0x8ac7,
            0x926c: 0x5024,
            0x926d: 0x77e5,
            0x926e: 0x5730,
            0x926f: 0x5f1b,
            0x9270: 0x6065,
            0x9271: 0x667a,
            0x9272: 0x6c60,
            0x9273: 0x75f4,
            0x9274: 0x7a1a,
            0x9275: 0x7f6e,
            0x9276: 0x81f4,
            0x9277: 0x8718,
            0x9278: 0x9045,
            0x9279: 0x99b3,
            0x927a: 0x7bc9,
            0x927b: 0x755c,
            0x927c: 0x7af9,
            0x927d: 0x7b51,
            0x927e: 0x84c4,
            0x9280: 0x9010,
            0x9281: 0x79e9,
            0x9282: 0x7a92,
            0x9283: 0x8336,
            0x9284: 0x5ae1,
            0x9285: 0x7740,
            0x9286: 0x4e2d,
            0x9287: 0x4ef2,
            0x9288: 0x5b99,
            0x9289: 0x5fe0,
            0x928a: 0x62bd,
            0x928b: 0x663c,
            0x928c: 0x67f1,
            0x928d: 0x6ce8,
            0x928e: 0x866b,
            0x928f: 0x8877,
            0x9290: 0x8a3b,
            0x9291: 0x914e,
            0x9292: 0x92f3,
            0x9293: 0x99d0,
            0x9294: 0x6a17,
            0x9295: 0x7026,
            0x9296: 0x732a,
            0x9297: 0x82e7,
            0x9298: 0x8457,
            0x9299: 0x8caf,
            0x929a: 0x4e01,
            0x929b: 0x5146,
            0x929c: 0x51cb,
            0x929d: 0x558b,
            0x929e: 0x5bf5,
            0x929f: 0x5e16,
            0x92a0: 0x5e33,
            0x92a1: 0x5e81,
            0x92a2: 0x5f14,
            0x92a3: 0x5f35,
            0x92a4: 0x5f6b,
            0x92a5: 0x5fb4,
            0x92a6: 0x61f2,
            0x92a7: 0x6311,
            0x92a8: 0x66a2,
            0x92a9: 0x671d,
            0x92aa: 0x6f6e,
            0x92ab: 0x7252,
            0x92ac: 0x753a,
            0x92ad: 0x773a,
            0x92ae: 0x8074,
            0x92af: 0x8139,
            0x92b0: 0x8178,
            0x92b1: 0x8776,
            0x92b2: 0x8abf,
            0x92b3: 0x8adc,
            0x92b4: 0x8d85,
            0x92b5: 0x8df3,
            0x92b6: 0x929a,
            0x92b7: 0x9577,
            0x92b8: 0x9802,
            0x92b9: 0x9ce5,
            0x92ba: 0x52c5,
            0x92bb: 0x6357,
            0x92bc: 0x76f4,
            0x92bd: 0x6715,
            0x92be: 0x6c88,
            0x92bf: 0x73cd,
            0x92c0: 0x8cc3,
            0x92c1: 0x93ae,
            0x92c2: 0x9673,
            0x92c3: 0x6d25,
            0x92c4: 0x589c,
            0x92c5: 0x690e,
            0x92c6: 0x69cc,
            0x92c7: 0x8ffd,
            0x92c8: 0x939a,
            0x92c9: 0x75db,
            0x92ca: 0x901a,
            0x92cb: 0x585a,
            0x92cc: 0x6802,
            0x92cd: 0x63b4,
            0x92ce: 0x69fb,
            0x92cf: 0x4f43,
            0x92d0: 0x6f2c,
            0x92d1: 0x67d8,
            0x92d2: 0x8fbb,
            0x92d3: 0x8526,
            0x92d4: 0x7db4,
            0x92d5: 0x9354,
            0x92d6: 0x693f,
            0x92d7: 0x6f70,
            0x92d8: 0x576a,
            0x92d9: 0x58f7,
            0x92da: 0x5b2c,
            0x92db: 0x7d2c,
            0x92dc: 0x722a,
            0x92dd: 0x540a,
            0x92de: 0x91e3,
            0x92df: 0x9db4,
            0x92e0: 0x4ead,
            0x92e1: 0x4f4e,
            0x92e2: 0x505c,
            0x92e3: 0x5075,
            0x92e4: 0x5243,
            0x92e5: 0x8c9e,
            0x92e6: 0x5448,
            0x92e7: 0x5824,
            0x92e8: 0x5b9a,
            0x92e9: 0x5e1d,
            0x92ea: 0x5e95,
            0x92eb: 0x5ead,
            0x92ec: 0x5ef7,
            0x92ed: 0x5f1f,
            0x92ee: 0x608c,
            0x92ef: 0x62b5,
            0x92f0: 0x633a,
            0x92f1: 0x63d0,
            0x92f2: 0x68af,
            0x92f3: 0x6c40,
            0x92f4: 0x7887,
            0x92f5: 0x798e,
            0x92f6: 0x7a0b,
            0x92f7: 0x7de0,
            0x92f8: 0x8247,
            0x92f9: 0x8a02,
            0x92fa: 0x8ae6,
            0x92fb: 0x8e44,
            0x92fc: 0x9013,
            0x9340: 0x90b8,
            0x9341: 0x912d,
            0x9342: 0x91d8,
            0x9343: 0x9f0e,
            0x9344: 0x6ce5,
            0x9345: 0x6458,
            0x9346: 0x64e2,
            0x9347: 0x6575,
            0x9348: 0x6ef4,
            0x9349: 0x7684,
            0x934a: 0x7b1b,
            0x934b: 0x9069,
            0x934c: 0x93d1,
            0x934d: 0x6eba,
            0x934e: 0x54f2,
            0x934f: 0x5fb9,
            0x9350: 0x64a4,
            0x9351: 0x8f4d,
            0x9352: 0x8fed,
            0x9353: 0x9244,
            0x9354: 0x5178,
            0x9355: 0x586b,
            0x9356: 0x5929,
            0x9357: 0x5c55,
            0x9358: 0x5e97,
            0x9359: 0x6dfb,
            0x935a: 0x7e8f,
            0x935b: 0x751c,
            0x935c: 0x8cbc,
            0x935d: 0x8ee2,
            0x935e: 0x985b,
            0x935f: 0x70b9,
            0x9360: 0x4f1d,
            0x9361: 0x6bbf,
            0x9362: 0x6fb1,
            0x9363: 0x7530,
            0x9364: 0x96fb,
            0x9365: 0x514e,
            0x9366: 0x5410,
            0x9367: 0x5835,
            0x9368: 0x5857,
            0x9369: 0x59ac,
            0x936a: 0x5c60,
            0x936b: 0x5f92,
            0x936c: 0x6597,
            0x936d: 0x675c,
            0x936e: 0x6e21,
            0x936f: 0x767b,
            0x9370: 0x83df,
            0x9371: 0x8ced,
            0x9372: 0x9014,
            0x9373: 0x90fd,
            0x9374: 0x934d,
            0x9375: 0x7825,
            0x9376: 0x783a,
            0x9377: 0x52aa,
            0x9378: 0x5ea6,
            0x9379: 0x571f,
            0x937a: 0x5974,
            0x937b: 0x6012,
            0x937c: 0x5012,
            0x937d: 0x515a,
            0x937e: 0x51ac,
            0x9380: 0x51cd,
            0x9381: 0x5200,
            0x9382: 0x5510,
            0x9383: 0x5854,
            0x9384: 0x5858,
            0x9385: 0x5957,
            0x9386: 0x5b95,
            0x9387: 0x5cf6,
            0x9388: 0x5d8b,
            0x9389: 0x60bc,
            0x938a: 0x6295,
            0x938b: 0x642d,
            0x938c: 0x6771,
            0x938d: 0x6843,
            0x938e: 0x68bc,
            0x938f: 0x68df,
            0x9390: 0x76d7,
            0x9391: 0x6dd8,
            0x9392: 0x6e6f,
            0x9393: 0x6d9b,
            0x9394: 0x706f,
            0x9395: 0x71c8,
            0x9396: 0x5f53,
            0x9397: 0x75d8,
            0x9398: 0x7977,
            0x9399: 0x7b49,
            0x939a: 0x7b54,
            0x939b: 0x7b52,
            0x939c: 0x7cd6,
            0x939d: 0x7d71,
            0x939e: 0x5230,
            0x939f: 0x8463,
            0x93a0: 0x8569,
            0x93a1: 0x85e4,
            0x93a2: 0x8a0e,
            0x93a3: 0x8b04,
            0x93a4: 0x8c46,
            0x93a5: 0x8e0f,
            0x93a6: 0x9003,
            0x93a7: 0x900f,
            0x93a8: 0x9419,
            0x93a9: 0x9676,
            0x93aa: 0x982d,
            0x93ab: 0x9a30,
            0x93ac: 0x95d8,
            0x93ad: 0x50cd,
            0x93ae: 0x52d5,
            0x93af: 0x540c,
            0x93b0: 0x5802,
            0x93b1: 0x5c0e,
            0x93b2: 0x61a7,
            0x93b3: 0x649e,
            0x93b4: 0x6d1e,
            0x93b5: 0x77b3,
            0x93b6: 0x7ae5,
            0x93b7: 0x80f4,
            0x93b8: 0x8404,
            0x93b9: 0x9053,
            0x93ba: 0x9285,
            0x93bb: 0x5ce0,
            0x93bc: 0x9d07,
            0x93bd: 0x533f,
            0x93be: 0x5f97,
            0x93bf: 0x5fb3,
            0x93c0: 0x6d9c,
            0x93c1: 0x7279,
            0x93c2: 0x7763,
            0x93c3: 0x79bf,
            0x93c4: 0x7be4,
            0x93c5: 0x6bd2,
            0x93c6: 0x72ec,
            0x93c7: 0x8aad,
            0x93c8: 0x6803,
            0x93c9: 0x6a61,
            0x93ca: 0x51f8,
            0x93cb: 0x7a81,
            0x93cc: 0x6934,
            0x93cd: 0x5c4a,
            0x93ce: 0x9cf6,
            0x93cf: 0x82eb,
            0x93d0: 0x5bc5,
            0x93d1: 0x9149,
            0x93d2: 0x701e,
            0x93d3: 0x5678,
            0x93d4: 0x5c6f,
            0x93d5: 0x60c7,
            0x93d6: 0x6566,
            0x93d7: 0x6c8c,
            0x93d8: 0x8c5a,
            0x93d9: 0x9041,
            0x93da: 0x9813,
            0x93db: 0x5451,
            0x93dc: 0x66c7,
            0x93dd: 0x920d,
            0x93de: 0x5948,
            0x93df: 0x90a3,
            0x93e0: 0x5185,
            0x93e1: 0x4e4d,
            0x93e2: 0x51ea,
            0x93e3: 0x8599,
            0x93e4: 0x8b0e,
            0x93e5: 0x7058,
            0x93e6: 0x637a,
            0x93e7: 0x934b,
            0x93e8: 0x6962,
            0x93e9: 0x99b4,
            0x93ea: 0x7e04,
            0x93eb: 0x7577,
            0x93ec: 0x5357,
            0x93ed: 0x6960,
            0x93ee: 0x8edf,
            0x93ef: 0x96e3,
            0x93f0: 0x6c5d,
            0x93f1: 0x4e8c,
            0x93f2: 0x5c3c,
            0x93f3: 0x5f10,
            0x93f4: 0x8fe9,
            0x93f5: 0x5302,
            0x93f6: 0x8cd1,
            0x93f7: 0x8089,
            0x93f8: 0x8679,
            0x93f9: 0x5eff,
            0x93fa: 0x65e5,
            0x93fb: 0x4e73,
            0x93fc: 0x5165,
            0x9440: 0x5982,
            0x9441: 0x5c3f,
            0x9442: 0x97ee,
            0x9443: 0x4efb,
            0x9444: 0x598a,
            0x9445: 0x5fcd,
            0x9446: 0x8a8d,
            0x9447: 0x6fe1,
            0x9448: 0x79b0,
            0x9449: 0x7962,
            0x944a: 0x5be7,
            0x944b: 0x8471,
            0x944c: 0x732b,
            0x944d: 0x71b1,
            0x944e: 0x5e74,
            0x944f: 0x5ff5,
            0x9450: 0x637b,
            0x9451: 0x649a,
            0x9452: 0x71c3,
            0x9453: 0x7c98,
            0x9454: 0x4e43,
            0x9455: 0x5efc,
            0x9456: 0x4e4b,
            0x9457: 0x57dc,
            0x9458: 0x56a2,
            0x9459: 0x60a9,
            0x945a: 0x6fc3,
            0x945b: 0x7d0d,
            0x945c: 0x80fd,
            0x945d: 0x8133,
            0x945e: 0x81bf,
            0x945f: 0x8fb2,
            0x9460: 0x8997,
            0x9461: 0x86a4,
            0x9462: 0x5df4,
            0x9463: 0x628a,
            0x9464: 0x64ad,
            0x9465: 0x8987,
            0x9466: 0x6777,
            0x9467: 0x6ce2,
            0x9468: 0x6d3e,
            0x9469: 0x7436,
            0x946a: 0x7834,
            0x946b: 0x5a46,
            0x946c: 0x7f75,
            0x946d: 0x82ad,
            0x946e: 0x99ac,
            0x946f: 0x4ff3,
            0x9470: 0x5ec3,
            0x9471: 0x62dd,
            0x9472: 0x6392,
            0x9473: 0x6557,
            0x9474: 0x676f,
            0x9475: 0x76c3,
            0x9476: 0x724c,
            0x9477: 0x80cc,
            0x9478: 0x80ba,
            0x9479: 0x8f29,
            0x947a: 0x914d,
            0x947b: 0x500d,
            0x947c: 0x57f9,
            0x947d: 0x5a92,
            0x947e: 0x6885,
            0x9480: 0x6973,
            0x9481: 0x7164,
            0x9482: 0x72fd,
            0x9483: 0x8cb7,
            0x9484: 0x58f2,
            0x9485: 0x8ce0,
            0x9486: 0x966a,
            0x9487: 0x9019,
            0x9488: 0x877f,
            0x9489: 0x79e4,
            0x948a: 0x77e7,
            0x948b: 0x8429,
            0x948c: 0x4f2f,
            0x948d: 0x5265,
            0x948e: 0x535a,
            0x948f: 0x62cd,
            0x9490: 0x67cf,
            0x9491: 0x6cca,
            0x9492: 0x767d,
            0x9493: 0x7b94,
            0x9494: 0x7c95,
            0x9495: 0x8236,
            0x9496: 0x8584,
            0x9497: 0x8feb,
            0x9498: 0x66dd,
            0x9499: 0x6f20,
            0x949a: 0x7206,
            0x949b: 0x7e1b,
            0x949c: 0x83ab,
            0x949d: 0x99c1,
            0x949e: 0x9ea6,
            0x949f: 0x51fd,
            0x94a0: 0x7bb1,
            0x94a1: 0x7872,
            0x94a2: 0x7bb8,
            0x94a3: 0x8087,
            0x94a4: 0x7b48,
            0x94a5: 0x6ae8,
            0x94a6: 0x5e61,
            0x94a7: 0x808c,
            0x94a8: 0x7551,
            0x94a9: 0x7560,
            0x94aa: 0x516b,
            0x94ab: 0x9262,
            0x94ac: 0x6e8c,
            0x94ad: 0x767a,
            0x94ae: 0x9197,
            0x94af: 0x9aea,
            0x94b0: 0x4f10,
            0x94b1: 0x7f70,
            0x94b2: 0x629c,
            0x94b3: 0x7b4f,
            0x94b4: 0x95a5,
            0x94b5: 0x9ce9,
            0x94b6: 0x567a,
            0x94b7: 0x5859,
            0x94b8: 0x86e4,
            0x94b9: 0x96bc,
            0x94ba: 0x4f34,
            0x94bb: 0x5224,
            0x94bc: 0x534a,
            0x94bd: 0x53cd,
            0x94be: 0x53db,
            0x94bf: 0x5e06,
            0x94c0: 0x642c,
            0x94c1: 0x6591,
            0x94c2: 0x677f,
            0x94c3: 0x6c3e,
            0x94c4: 0x6c4e,
            0x94c5: 0x7248,
            0x94c6: 0x72af,
            0x94c7: 0x73ed,
            0x94c8: 0x7554,
            0x94c9: 0x7e41,
            0x94ca: 0x822c,
            0x94cb: 0x85e9,
            0x94cc: 0x8ca9,
            0x94cd: 0x7bc4,
            0x94ce: 0x91c6,
            0x94cf: 0x7169,
            0x94d0: 0x9812,
            0x94d1: 0x98ef,
            0x94d2: 0x633d,
            0x94d3: 0x6669,
            0x94d4: 0x756a,
            0x94d5: 0x76e4,
            0x94d6: 0x78d0,
            0x94d7: 0x8543,
            0x94d8: 0x86ee,
            0x94d9: 0x532a,
            0x94da: 0x5351,
            0x94db: 0x5426,
            0x94dc: 0x5983,
            0x94dd: 0x5e87,
            0x94de: 0x5f7c,
            0x94df: 0x60b2,
            0x94e0: 0x6249,
            0x94e1: 0x6279,
            0x94e2: 0x62ab,
            0x94e3: 0x6590,
            0x94e4: 0x6bd4,
            0x94e5: 0x6ccc,
            0x94e6: 0x75b2,
            0x94e7: 0x76ae,
            0x94e8: 0x7891,
            0x94e9: 0x79d8,
            0x94ea: 0x7dcb,
            0x94eb: 0x7f77,
            0x94ec: 0x80a5,
            0x94ed: 0x88ab,
            0x94ee: 0x8ab9,
            0x94ef: 0x8cbb,
            0x94f0: 0x907f,
            0x94f1: 0x975e,
            0x94f2: 0x98db,
            0x94f3: 0x6a0b,
            0x94f4: 0x7c38,
            0x94f5: 0x5099,
            0x94f6: 0x5c3e,
            0x94f7: 0x5fae,
            0x94f8: 0x6787,
            0x94f9: 0x6bd8,
            0x94fa: 0x7435,
            0x94fb: 0x7709,
            0x94fc: 0x7f8e,
            0x9540: 0x9f3b,
            0x9541: 0x67ca,
            0x9542: 0x7a17,
            0x9543: 0x5339,
            0x9544: 0x758b,
            0x9545: 0x9aed,
            0x9546: 0x5f66,
            0x9547: 0x819d,
            0x9548: 0x83f1,
            0x9549: 0x8098,
            0x954a: 0x5f3c,
            0x954b: 0x5fc5,
            0x954c: 0x7562,
            0x954d: 0x7b46,
            0x954e: 0x903c,
            0x954f: 0x6867,
            0x9550: 0x59eb,
            0x9551: 0x5a9b,
            0x9552: 0x7d10,
            0x9553: 0x767e,
            0x9554: 0x8b2c,
            0x9555: 0x4ff5,
            0x9556: 0x5f6a,
            0x9557: 0x6a19,
            0x9558: 0x6c37,
            0x9559: 0x6f02,
            0x955a: 0x74e2,
            0x955b: 0x7968,
            0x955c: 0x8868,
            0x955d: 0x8a55,
            0x955e: 0x8c79,
            0x955f: 0x5edf,
            0x9560: 0x63cf,
            0x9561: 0x75c5,
            0x9562: 0x79d2,
            0x9563: 0x82d7,
            0x9564: 0x9328,
            0x9565: 0x92f2,
            0x9566: 0x849c,
            0x9567: 0x86ed,
            0x9568: 0x9c2d,
            0x9569: 0x54c1,
            0x956a: 0x5f6c,
            0x956b: 0x658c,
            0x956c: 0x6d5c,
            0x956d: 0x7015,
            0x956e: 0x8ca7,
            0x956f: 0x8cd3,
            0x9570: 0x983b,
            0x9571: 0x654f,
            0x9572: 0x74f6,
            0x9573: 0x4e0d,
            0x9574: 0x4ed8,
            0x9575: 0x57e0,
            0x9576: 0x592b,
            0x9577: 0x5a66,
            0x9578: 0x5bcc,
            0x9579: 0x51a8,
            0x957a: 0x5e03,
            0x957b: 0x5e9c,
            0x957c: 0x6016,
            0x957d: 0x6276,
            0x957e: 0x6577,
            0x9580: 0x65a7,
            0x9581: 0x666e,
            0x9582: 0x6d6e,
            0x9583: 0x7236,
            0x9584: 0x7b26,
            0x9585: 0x8150,
            0x9586: 0x819a,
            0x9587: 0x8299,
            0x9588: 0x8b5c,
            0x9589: 0x8ca0,
            0x958a: 0x8ce6,
            0x958b: 0x8d74,
            0x958c: 0x961c,
            0x958d: 0x9644,
            0x958e: 0x4fae,
            0x958f: 0x64ab,
            0x9590: 0x6b66,
            0x9591: 0x821e,
            0x9592: 0x8461,
            0x9593: 0x856a,
            0x9594: 0x90e8,
            0x9595: 0x5c01,
            0x9596: 0x6953,
            0x9597: 0x98a8,
            0x9598: 0x847a,
            0x9599: 0x8557,
            0x959a: 0x4f0f,
            0x959b: 0x526f,
            0x959c: 0x5fa9,
            0x959d: 0x5e45,
            0x959e: 0x670d,
            0x959f: 0x798f,
            0x95a0: 0x8179,
            0x95a1: 0x8907,
            0x95a2: 0x8986,
            0x95a3: 0x6df5,
            0x95a4: 0x5f17,
            0x95a5: 0x6255,
            0x95a6: 0x6cb8,
            0x95a7: 0x4ecf,
            0x95a8: 0x7269,
            0x95a9: 0x9b92,
            0x95aa: 0x5206,
            0x95ab: 0x543b,
            0x95ac: 0x5674,
            0x95ad: 0x58b3,
            0x95ae: 0x61a4,
            0x95af: 0x626e,
            0x95b0: 0x711a,
            0x95b1: 0x596e,
            0x95b2: 0x7c89,
            0x95b3: 0x7cde,
            0x95b4: 0x7d1b,
            0x95b5: 0x96f0,
            0x95b6: 0x6587,
            0x95b7: 0x805e,
            0x95b8: 0x4e19,
            0x95b9: 0x4f75,
            0x95ba: 0x5175,
            0x95bb: 0x5840,
            0x95bc: 0x5e63,
            0x95bd: 0x5e73,
            0x95be: 0x5f0a,
            0x95bf: 0x67c4,
            0x95c0: 0x4e26,
            0x95c1: 0x853d,
            0x95c2: 0x9589,
            0x95c3: 0x965b,
            0x95c4: 0x7c73,
            0x95c5: 0x9801,
            0x95c6: 0x50fb,
            0x95c7: 0x58c1,
            0x95c8: 0x7656,
            0x95c9: 0x78a7,
            0x95ca: 0x5225,
            0x95cb: 0x77a5,
            0x95cc: 0x8511,
            0x95cd: 0x7b86,
            0x95ce: 0x504f,
            0x95cf: 0x5909,
            0x95d0: 0x7247,
            0x95d1: 0x7bc7,
            0x95d2: 0x7de8,
            0x95d3: 0x8fba,
            0x95d4: 0x8fd4,
            0x95d5: 0x904d,
            0x95d6: 0x4fbf,
            0x95d7: 0x52c9,
            0x95d8: 0x5a29,
            0x95d9: 0x5f01,
            0x95da: 0x97ad,
            0x95db: 0x4fdd,
            0x95dc: 0x8217,
            0x95dd: 0x92ea,
            0x95de: 0x5703,
            0x95df: 0x6355,
            0x95e0: 0x6b69,
            0x95e1: 0x752b,
            0x95e2: 0x88dc,
            0x95e3: 0x8f14,
            0x95e4: 0x7a42,
            0x95e5: 0x52df,
            0x95e6: 0x5893,
            0x95e7: 0x6155,
            0x95e8: 0x620a,
            0x95e9: 0x66ae,
            0x95ea: 0x6bcd,
            0x95eb: 0x7c3f,
            0x95ec: 0x83e9,
            0x95ed: 0x5023,
            0x95ee: 0x4ff8,
            0x95ef: 0x5305,
            0x95f0: 0x5446,
            0x95f1: 0x5831,
            0x95f2: 0x5949,
            0x95f3: 0x5b9d,
            0x95f4: 0x5cf0,
            0x95f5: 0x5cef,
            0x95f6: 0x5d29,
            0x95f7: 0x5e96,
            0x95f8: 0x62b1,
            0x95f9: 0x6367,
            0x95fa: 0x653e,
            0x95fb: 0x65b9,
            0x95fc: 0x670b,
            0x9640: 0x6cd5,
            0x9641: 0x6ce1,
            0x9642: 0x70f9,
            0x9643: 0x7832,
            0x9644: 0x7e2b,
            0x9645: 0x80de,
            0x9646: 0x82b3,
            0x9647: 0x840c,
            0x9648: 0x84ec,
            0x9649: 0x8702,
            0x964a: 0x8912,
            0x964b: 0x8a2a,
            0x964c: 0x8c4a,
            0x964d: 0x90a6,
            0x964e: 0x92d2,
            0x964f: 0x98fd,
            0x9650: 0x9cf3,
            0x9651: 0x9d6c,
            0x9652: 0x4e4f,
            0x9653: 0x4ea1,
            0x9654: 0x508d,
            0x9655: 0x5256,
            0x9656: 0x574a,
            0x9657: 0x59a8,
            0x9658: 0x5e3d,
            0x9659: 0x5fd8,
            0x965a: 0x5fd9,
            0x965b: 0x623f,
            0x965c: 0x66b4,
            0x965d: 0x671b,
            0x965e: 0x67d0,
            0x965f: 0x68d2,
            0x9660: 0x5192,
            0x9661: 0x7d21,
            0x9662: 0x80aa,
            0x9663: 0x81a8,
            0x9664: 0x8b00,
            0x9665: 0x8c8c,
            0x9666: 0x8cbf,
            0x9667: 0x927e,
            0x9668: 0x9632,
            0x9669: 0x5420,
            0x966a: 0x982c,
            0x966b: 0x5317,
            0x966c: 0x50d5,
            0x966d: 0x535c,
            0x966e: 0x58a8,
            0x966f: 0x64b2,
            0x9670: 0x6734,
            0x9671: 0x7267,
            0x9672: 0x7766,
            0x9673: 0x7a46,
            0x9674: 0x91e6,
            0x9675: 0x52c3,
            0x9676: 0x6ca1,
            0x9677: 0x6b86,
            0x9678: 0x5800,
            0x9679: 0x5e4c,
            0x967a: 0x5954,
            0x967b: 0x672c,
            0x967c: 0x7ffb,
            0x967d: 0x51e1,
            0x967e: 0x76c6,
            0x9680: 0x6469,
            0x9681: 0x78e8,
            0x9682: 0x9b54,
            0x9683: 0x9ebb,
            0x9684: 0x57cb,
            0x9685: 0x59b9,
            0x9686: 0x6627,
            0x9687: 0x679a,
            0x9688: 0x6bce,
            0x9689: 0x54e9,
            0x968a: 0x69d9,
            0x968b: 0x5e55,
            0x968c: 0x819c,
            0x968d: 0x6795,
            0x968e: 0x9baa,
            0x968f: 0x67fe,
            0x9690: 0x9c52,
            0x9691: 0x685d,
            0x9692: 0x4ea6,
            0x9693: 0x4fe3,
            0x9694: 0x53c8,
            0x9695: 0x62b9,
            0x9696: 0x672b,
            0x9697: 0x6cab,
            0x9698: 0x8fc4,
            0x9699: 0x4fad,
            0x969a: 0x7e6d,
            0x969b: 0x9ebf,
            0x969c: 0x4e07,
            0x969d: 0x6162,
            0x969e: 0x6e80,
            0x969f: 0x6f2b,
            0x96a0: 0x8513,
            0x96a1: 0x5473,
            0x96a2: 0x672a,
            0x96a3: 0x9b45,
            0x96a4: 0x5df3,
            0x96a5: 0x7b95,
            0x96a6: 0x5cac,
            0x96a7: 0x5bc6,
            0x96a8: 0x871c,
            0x96a9: 0x6e4a,
            0x96aa: 0x84d1,
            0x96ab: 0x7a14,
            0x96ac: 0x8108,
            0x96ad: 0x5999,
            0x96ae: 0x7c8d,
            0x96af: 0x6c11,
            0x96b0: 0x7720,
            0x96b1: 0x52d9,
            0x96b2: 0x5922,
            0x96b3: 0x7121,
            0x96b4: 0x725f,
            0x96b5: 0x77db,
            0x96b6: 0x9727,
            0x96b7: 0x9d61,
            0x96b8: 0x690b,
            0x96b9: 0x5a7f,
            0x96ba: 0x5a18,
            0x96bb: 0x51a5,
            0x96bc: 0x540d,
            0x96bd: 0x547d,
            0x96be: 0x660e,
            0x96bf: 0x76df,
            0x96c0: 0x8ff7,
            0x96c1: 0x9298,
            0x96c2: 0x9cf4,
            0x96c3: 0x59ea,
            0x96c4: 0x725d,
            0x96c5: 0x6ec5,
            0x96c6: 0x514d,
            0x96c7: 0x68c9,
            0x96c8: 0x7dbf,
            0x96c9: 0x7dec,
            0x96ca: 0x9762,
            0x96cb: 0x9eba,
            0x96cc: 0x6478,
            0x96cd: 0x6a21,
            0x96ce: 0x8302,
            0x96cf: 0x5984,
            0x96d0: 0x5b5f,
            0x96d1: 0x6bdb,
            0x96d2: 0x731b,
            0x96d3: 0x76f2,
            0x96d4: 0x7db2,
            0x96d5: 0x8017,
            0x96d6: 0x8499,
            0x96d7: 0x5132,
            0x96d8: 0x6728,
            0x96d9: 0x9ed9,
            0x96da: 0x76ee,
            0x96db: 0x6762,
            0x96dc: 0x52ff,
            0x96dd: 0x9905,
            0x96de: 0x5c24,
            0x96df: 0x623b,
            0x96e0: 0x7c7e,
            0x96e1: 0x8cb0,
            0x96e2: 0x554f,
            0x96e3: 0x60b6,
            0x96e4: 0x7d0b,
            0x96e5: 0x9580,
            0x96e6: 0x5301,
            0x96e7: 0x4e5f,
            0x96e8: 0x51b6,
            0x96e9: 0x591c,
            0x96ea: 0x723a,
            0x96eb: 0x8036,
            0x96ec: 0x91ce,
            0x96ed: 0x5f25,
            0x96ee: 0x77e2,
            0x96ef: 0x5384,
            0x96f0: 0x5f79,
            0x96f1: 0x7d04,
            0x96f2: 0x85ac,
            0x96f3: 0x8a33,
            0x96f4: 0x8e8d,
            0x96f5: 0x9756,
            0x96f6: 0x67f3,
            0x96f7: 0x85ae,
            0x96f8: 0x9453,
            0x96f9: 0x6109,
            0x96fa: 0x6108,
            0x96fb: 0x6cb9,
            0x96fc: 0x7652,
            0x9740: 0x8aed,
            0x9741: 0x8f38,
            0x9742: 0x552f,
            0x9743: 0x4f51,
            0x9744: 0x512a,
            0x9745: 0x52c7,
            0x9746: 0x53cb,
            0x9747: 0x5ba5,
            0x9748: 0x5e7d,
            0x9749: 0x60a0,
            0x974a: 0x6182,
            0x974b: 0x63d6,
            0x974c: 0x6709,
            0x974d: 0x67da,
            0x974e: 0x6e67,
            0x974f: 0x6d8c,
            0x9750: 0x7336,
            0x9751: 0x7337,
            0x9752: 0x7531,
            0x9753: 0x7950,
            0x9754: 0x88d5,
            0x9755: 0x8a98,
            0x9756: 0x904a,
            0x9757: 0x9091,
            0x9758: 0x90f5,
            0x9759: 0x96c4,
            0x975a: 0x878d,
            0x975b: 0x5915,
            0x975c: 0x4e88,
            0x975d: 0x4f59,
            0x975e: 0x4e0e,
            0x975f: 0x8a89,
            0x9760: 0x8f3f,
            0x9761: 0x9810,
            0x9762: 0x50ad,
            0x9763: 0x5e7c,
            0x9764: 0x5996,
            0x9765: 0x5bb9,
            0x9766: 0x5eb8,
            0x9767: 0x63da,
            0x9768: 0x63fa,
            0x9769: 0x64c1,
            0x976a: 0x66dc,
            0x976b: 0x694a,
            0x976c: 0x69d8,
            0x976d: 0x6d0b,
            0x976e: 0x6eb6,
            0x976f: 0x7194,
            0x9770: 0x7528,
            0x9771: 0x7aaf,
            0x9772: 0x7f8a,
            0x9773: 0x8000,
            0x9774: 0x8449,
            0x9775: 0x84c9,
            0x9776: 0x8981,
            0x9777: 0x8b21,
            0x9778: 0x8e0a,
            0x9779: 0x9065,
            0x977a: 0x967d,
            0x977b: 0x990a,
            0x977c: 0x617e,
            0x977d: 0x6291,
            0x977e: 0x6b32,
            0x9780: 0x6c83,
            0x9781: 0x6d74,
            0x9782: 0x7fcc,
            0x9783: 0x7ffc,
            0x9784: 0x6dc0,
            0x9785: 0x7f85,
            0x9786: 0x87ba,
            0x9787: 0x88f8,
            0x9788: 0x6765,
            0x9789: 0x83b1,
            0x978a: 0x983c,
            0x978b: 0x96f7,
            0x978c: 0x6d1b,
            0x978d: 0x7d61,
            0x978e: 0x843d,
            0x978f: 0x916a,
            0x9790: 0x4e71,
            0x9791: 0x5375,
            0x9792: 0x5d50,
            0x9793: 0x6b04,
            0x9794: 0x6feb,
            0x9795: 0x85cd,
            0x9796: 0x862d,
            0x9797: 0x89a7,
            0x9798: 0x5229,
            0x9799: 0x540f,
            0x979a: 0x5c65,
            0x979b: 0x674e,
            0x979c: 0x68a8,
            0x979d: 0x7406,
            0x979e: 0x7483,
            0x979f: 0x75e2,
            0x97a0: 0x88cf,
            0x97a1: 0x88e1,
            0x97a2: 0x91cc,
            0x97a3: 0x96e2,
            0x97a4: 0x9678,
            0x97a5: 0x5f8b,
            0x97a6: 0x7387,
            0x97a7: 0x7acb,
            0x97a8: 0x844e,
            0x97a9: 0x63a0,
            0x97aa: 0x7565,
            0x97ab: 0x5289,
            0x97ac: 0x6d41,
            0x97ad: 0x6e9c,
            0x97ae: 0x7409,
            0x97af: 0x7559,
            0x97b0: 0x786b,
            0x97b1: 0x7c92,
            0x97b2: 0x9686,
            0x97b3: 0x7adc,
            0x97b4: 0x9f8d,
            0x97b5: 0x4fb6,
            0x97b6: 0x616e,
            0x97b7: 0x65c5,
            0x97b8: 0x865c,
            0x97b9: 0x4e86,
            0x97ba: 0x4eae,
            0x97bb: 0x50da,
            0x97bc: 0x4e21,
            0x97bd: 0x51cc,
            0x97be: 0x5bee,
            0x97bf: 0x6599,
            0x97c0: 0x6881,
            0x97c1: 0x6dbc,
            0x97c2: 0x731f,
            0x97c3: 0x7642,
            0x97c4: 0x77ad,
            0x97c5: 0x7a1c,
            0x97c6: 0x7ce7,
            0x97c7: 0x826f,
            0x97c8: 0x8ad2,
            0x97c9: 0x907c,
            0x97ca: 0x91cf,
            0x97cb: 0x9675,
            0x97cc: 0x9818,
            0x97cd: 0x529b,
            0x97ce: 0x7dd1,
            0x97cf: 0x502b,
            0x97d0: 0x5398,
            0x97d1: 0x6797,
            0x97d2: 0x6dcb,
            0x97d3: 0x71d0,
            0x97d4: 0x7433,
            0x97d5: 0x81e8,
            0x97d6: 0x8f2a,
            0x97d7: 0x96a3,
            0x97d8: 0x9c57,
            0x97d9: 0x9e9f,
            0x97da: 0x7460,
            0x97db: 0x5841,
            0x97dc: 0x6d99,
            0x97dd: 0x7d2f,
            0x97de: 0x985e,
            0x97df: 0x4ee4,
            0x97e0: 0x4f36,
            0x97e1: 0x4f8b,
            0x97e2: 0x51b7,
            0x97e3: 0x52b1,
            0x97e4: 0x5dba,
            0x97e5: 0x601c,
            0x97e6: 0x73b2,
            0x97e7: 0x793c,
            0x97e8: 0x82d3,
            0x97e9: 0x9234,
            0x97ea: 0x96b7,
            0x97eb: 0x96f6,
            0x97ec: 0x970a,
            0x97ed: 0x9e97,
            0x97ee: 0x9f62,
            0x97ef: 0x66a6,
            0x97f0: 0x6b74,
            0x97f1: 0x5217,
            0x97f2: 0x52a3,
            0x97f3: 0x70c8,
            0x97f4: 0x88c2,
            0x97f5: 0x5ec9,
            0x97f6: 0x604b,
            0x97f7: 0x6190,
            0x97f8: 0x6f23,
            0x97f9: 0x7149,
            0x97fa: 0x7c3e,
            0x97fb: 0x7df4,
            0x97fc: 0x806f,
            0x9840: 0x84ee,
            0x9841: 0x9023,
            0x9842: 0x932c,
            0x9843: 0x5442,
            0x9844: 0x9b6f,
            0x9845: 0x6ad3,
            0x9846: 0x7089,
            0x9847: 0x8cc2,
            0x9848: 0x8def,
            0x9849: 0x9732,
            0x984a: 0x52b4,
            0x984b: 0x5a41,
            0x984c: 0x5eca,
            0x984d: 0x5f04,
            0x984e: 0x6717,
            0x984f: 0x697c,
            0x9850: 0x6994,
            0x9851: 0x6d6a,
            0x9852: 0x6f0f,
            0x9853: 0x7262,
            0x9854: 0x72fc,
            0x9855: 0x7bed,
            0x9856: 0x8001,
            0x9857: 0x807e,
            0x9858: 0x874b,
            0x9859: 0x90ce,
            0x985a: 0x516d,
            0x985b: 0x9e93,
            0x985c: 0x7984,
            0x985d: 0x808b,
            0x985e: 0x9332,
            0x985f: 0x8ad6,
            0x9860: 0x502d,
            0x9861: 0x548c,
            0x9862: 0x8a71,
            0x9863: 0x6b6a,
            0x9864: 0x8cc4,
            0x9865: 0x8107,
            0x9866: 0x60d1,
            0x9867: 0x67a0,
            0x9868: 0x9df2,
            0x9869: 0x4e99,
            0x986a: 0x4e98,
            0x986b: 0x9c10,
            0x986c: 0x8a6b,
            0x986d: 0x85c1,
            0x986e: 0x8568,
            0x986f: 0x6900,
            0x9870: 0x6e7e,
            0x9871: 0x7897,
            0x9872: 0x8155,
            0x989f: 0x5f0c,
            0x98a0: 0x4e10,
            0x98a1: 0x4e15,
            0x98a2: 0x4e2a,
            0x98a3: 0x4e31,
            0x98a4: 0x4e36,
            0x98a5: 0x4e3c,
            0x98a6: 0x4e3f,
            0x98a7: 0x4e42,
            0x98a8: 0x4e56,
            0x98a9: 0x4e58,
            0x98aa: 0x4e82,
            0x98ab: 0x4e85,
            0x98ac: 0x8c6b,
            0x98ad: 0x4e8a,
            0x98ae: 0x8212,
            0x98af: 0x5f0d,
            0x98b0: 0x4e8e,
            0x98b1: 0x4e9e,
            0x98b2: 0x4e9f,
            0x98b3: 0x4ea0,
            0x98b4: 0x4ea2,
            0x98b5: 0x4eb0,
            0x98b6: 0x4eb3,
            0x98b7: 0x4eb6,
            0x98b8: 0x4ece,
            0x98b9: 0x4ecd,
            0x98ba: 0x4ec4,
            0x98bb: 0x4ec6,
            0x98bc: 0x4ec2,
            0x98bd: 0x4ed7,
            0x98be: 0x4ede,
            0x98bf: 0x4eed,
            0x98c0: 0x4edf,
            0x98c1: 0x4ef7,
            0x98c2: 0x4f09,
            0x98c3: 0x4f5a,
            0x98c4: 0x4f30,
            0x98c5: 0x4f5b,
            0x98c6: 0x4f5d,
            0x98c7: 0x4f57,
            0x98c8: 0x4f47,
            0x98c9: 0x4f76,
            0x98ca: 0x4f88,
            0x98cb: 0x4f8f,
            0x98cc: 0x4f98,
            0x98cd: 0x4f7b,
            0x98ce: 0x4f69,
            0x98cf: 0x4f70,
            0x98d0: 0x4f91,
            0x98d1: 0x4f6f,
            0x98d2: 0x4f86,
            0x98d3: 0x4f96,
            0x98d4: 0x5118,
            0x98d5: 0x4fd4,
            0x98d6: 0x4fdf,
            0x98d7: 0x4fce,
            0x98d8: 0x4fd8,
            0x98d9: 0x4fdb,
            0x98da: 0x4fd1,
            0x98db: 0x4fda,
            0x98dc: 0x4fd0,
            0x98dd: 0x4fe4,
            0x98de: 0x4fe5,
            0x98df: 0x501a,
            0x98e0: 0x5028,
            0x98e1: 0x5014,
            0x98e2: 0x502a,
            0x98e3: 0x5025,
            0x98e4: 0x5005,
            0x98e5: 0x4f1c,
            0x98e6: 0x4ff6,
            0x98e7: 0x5021,
            0x98e8: 0x5029,
            0x98e9: 0x502c,
            0x98ea: 0x4ffe,
            0x98eb: 0x4fef,
            0x98ec: 0x5011,
            0x98ed: 0x5006,
            0x98ee: 0x5043,
            0x98ef: 0x5047,
            0x98f0: 0x6703,
            0x98f1: 0x5055,
            0x98f2: 0x5050,
            0x98f3: 0x5048,
            0x98f4: 0x505a,
            0x98f5: 0x5056,
            0x98f6: 0x506c,
            0x98f7: 0x5078,
            0x98f8: 0x5080,
            0x98f9: 0x509a,
            0x98fa: 0x5085,
            0x98fb: 0x50b4,
            0x98fc: 0x50b2,
            0x9940: 0x50c9,
            0x9941: 0x50ca,
            0x9942: 0x50b3,
            0x9943: 0x50c2,
            0x9944: 0x50d6,
            0x9945: 0x50de,
            0x9946: 0x50e5,
            0x9947: 0x50ed,
            0x9948: 0x50e3,
            0x9949: 0x50ee,
            0x994a: 0x50f9,
            0x994b: 0x50f5,
            0x994c: 0x5109,
            0x994d: 0x5101,
            0x994e: 0x5102,
            0x994f: 0x5116,
            0x9950: 0x5115,
            0x9951: 0x5114,
            0x9952: 0x511a,
            0x9953: 0x5121,
            0x9954: 0x513a,
            0x9955: 0x5137,
            0x9956: 0x513c,
            0x9957: 0x513b,
            0x9958: 0x513f,
            0x9959: 0x5140,
            0x995a: 0x5152,
            0x995b: 0x514c,
            0x995c: 0x5154,
            0x995d: 0x5162,
            0x995e: 0x7af8,
            0x995f: 0x5169,
            0x9960: 0x516a,
            0x9961: 0x516e,
            0x9962: 0x5180,
            0x9963: 0x5182,
            0x9964: 0x56d8,
            0x9965: 0x518c,
            0x9966: 0x5189,
            0x9967: 0x518f,
            0x9968: 0x5191,
            0x9969: 0x5193,
            0x996a: 0x5195,
            0x996b: 0x5196,
            0x996c: 0x51a4,
            0x996d: 0x51a6,
            0x996e: 0x51a2,
            0x996f: 0x51a9,
            0x9970: 0x51aa,
            0x9971: 0x51ab,
            0x9972: 0x51b3,
            0x9973: 0x51b1,
            0x9974: 0x51b2,
            0x9975: 0x51b0,
            0x9976: 0x51b5,
            0x9977: 0x51bd,
            0x9978: 0x51c5,
            0x9979: 0x51c9,
            0x997a: 0x51db,
            0x997b: 0x51e0,
            0x997c: 0x8655,
            0x997d: 0x51e9,
            0x997e: 0x51ed,
            0x9980: 0x51f0,
            0x9981: 0x51f5,
            0x9982: 0x51fe,
            0x9983: 0x5204,
            0x9984: 0x520b,
            0x9985: 0x5214,
            0x9986: 0x520e,
            0x9987: 0x5227,
            0x9988: 0x522a,
            0x9989: 0x522e,
            0x998a: 0x5233,
            0x998b: 0x5239,
            0x998c: 0x524f,
            0x998d: 0x5244,
            0x998e: 0x524b,
            0x998f: 0x524c,
            0x9990: 0x525e,
            0x9991: 0x5254,
            0x9992: 0x526a,
            0x9993: 0x5274,
            0x9994: 0x5269,
            0x9995: 0x5273,
            0x9996: 0x527f,
            0x9997: 0x527d,
            0x9998: 0x528d,
            0x9999: 0x5294,
            0x999a: 0x5292,
            0x999b: 0x5271,
            0x999c: 0x5288,
            0x999d: 0x5291,
            0x999e: 0x8fa8,
            0x999f: 0x8fa7,
            0x99a0: 0x52ac,
            0x99a1: 0x52ad,
            0x99a2: 0x52bc,
            0x99a3: 0x52b5,
            0x99a4: 0x52c1,
            0x99a5: 0x52cd,
            0x99a6: 0x52d7,
            0x99a7: 0x52de,
            0x99a8: 0x52e3,
            0x99a9: 0x52e6,
            0x99aa: 0x98ed,
            0x99ab: 0x52e0,
            0x99ac: 0x52f3,
            0x99ad: 0x52f5,
            0x99ae: 0x52f8,
            0x99af: 0x52f9,
            0x99b0: 0x5306,
            0x99b1: 0x5308,
            0x99b2: 0x7538,
            0x99b3: 0x530d,
            0x99b4: 0x5310,
            0x99b5: 0x530f,
            0x99b6: 0x5315,
            0x99b7: 0x531a,
            0x99b8: 0x5323,
            0x99b9: 0x532f,
            0x99ba: 0x5331,
            0x99bb: 0x5333,
            0x99bc: 0x5338,
            0x99bd: 0x5340,
            0x99be: 0x5346,
            0x99bf: 0x5345,
            0x99c0: 0x4e17,
            0x99c1: 0x5349,
            0x99c2: 0x534d,
            0x99c3: 0x51d6,
            0x99c4: 0x535e,
            0x99c5: 0x5369,
            0x99c6: 0x536e,
            0x99c7: 0x5918,
            0x99c8: 0x537b,
            0x99c9: 0x5377,
            0x99ca: 0x5382,
            0x99cb: 0x5396,
            0x99cc: 0x53a0,
            0x99cd: 0x53a6,
            0x99ce: 0x53a5,
            0x99cf: 0x53ae,
            0x99d0: 0x53b0,
            0x99d1: 0x53b6,
            0x99d2: 0x53c3,
            0x99d3: 0x7c12,
            0x99d4: 0x96d9,
            0x99d5: 0x53df,
            0x99d6: 0x66fc,
            0x99d7: 0x71ee,
            0x99d8: 0x53ee,
            0x99d9: 0x53e8,
            0x99da: 0x53ed,
            0x99db: 0x53fa,
            0x99dc: 0x5401,
            0x99dd: 0x543d,
            0x99de: 0x5440,
            0x99df: 0x542c,
            0x99e0: 0x542d,
            0x99e1: 0x543c,
            0x99e2: 0x542e,
            0x99e3: 0x5436,
            0x99e4: 0x5429,
            0x99e5: 0x541d,
            0x99e6: 0x544e,
            0x99e7: 0x548f,
            0x99e8: 0x5475,
            0x99e9: 0x548e,
            0x99ea: 0x545f,
            0x99eb: 0x5471,
            0x99ec: 0x5477,
            0x99ed: 0x5470,
            0x99ee: 0x5492,
            0x99ef: 0x547b,
            0x99f0: 0x5480,
            0x99f1: 0x5476,
            0x99f2: 0x5484,
            0x99f3: 0x5490,
            0x99f4: 0x5486,
            0x99f5: 0x54c7,
            0x99f6: 0x54a2,
            0x99f7: 0x54b8,
            0x99f8: 0x54a5,
            0x99f9: 0x54ac,
            0x99fa: 0x54c4,
            0x99fb: 0x54c8,
            0x99fc: 0x54a8,
            0x9a40: 0x54ab,
            0x9a41: 0x54c2,
            0x9a42: 0x54a4,
            0x9a43: 0x54be,
            0x9a44: 0x54bc,
            0x9a45: 0x54d8,
            0x9a46: 0x54e5,
            0x9a47: 0x54e6,
            0x9a48: 0x550f,
            0x9a49: 0x5514,
            0x9a4a: 0x54fd,
            0x9a4b: 0x54ee,
            0x9a4c: 0x54ed,
            0x9a4d: 0x54fa,
            0x9a4e: 0x54e2,
            0x9a4f: 0x5539,
            0x9a50: 0x5540,
            0x9a51: 0x5563,
            0x9a52: 0x554c,
            0x9a53: 0x552e,
            0x9a54: 0x555c,
            0x9a55: 0x5545,
            0x9a56: 0x5556,
            0x9a57: 0x5557,
            0x9a58: 0x5538,
            0x9a59: 0x5533,
            0x9a5a: 0x555d,
            0x9a5b: 0x5599,
            0x9a5c: 0x5580,
            0x9a5d: 0x54af,
            0x9a5e: 0x558a,
            0x9a5f: 0x559f,
            0x9a60: 0x557b,
            0x9a61: 0x557e,
            0x9a62: 0x5598,
            0x9a63: 0x559e,
            0x9a64: 0x55ae,
            0x9a65: 0x557c,
            0x9a66: 0x5583,
            0x9a67: 0x55a9,
            0x9a68: 0x5587,
            0x9a69: 0x55a8,
            0x9a6a: 0x55da,
            0x9a6b: 0x55c5,
            0x9a6c: 0x55df,
            0x9a6d: 0x55c4,
            0x9a6e: 0x55dc,
            0x9a6f: 0x55e4,
            0x9a70: 0x55d4,
            0x9a71: 0x5614,
            0x9a72: 0x55f7,
            0x9a73: 0x5616,
            0x9a74: 0x55fe,
            0x9a75: 0x55fd,
            0x9a76: 0x561b,
            0x9a77: 0x55f9,
            0x9a78: 0x564e,
            0x9a79: 0x5650,
            0x9a7a: 0x71df,
            0x9a7b: 0x5634,
            0x9a7c: 0x5636,
            0x9a7d: 0x5632,
            0x9a7e: 0x5638,
            0x9a80: 0x566b,
            0x9a81: 0x5664,
            0x9a82: 0x562f,
            0x9a83: 0x566c,
            0x9a84: 0x566a,
            0x9a85: 0x5686,
            0x9a86: 0x5680,
            0x9a87: 0x568a,
            0x9a88: 0x56a0,
            0x9a89: 0x5694,
            0x9a8a: 0x568f,
            0x9a8b: 0x56a5,
            0x9a8c: 0x56ae,
            0x9a8d: 0x56b6,
            0x9a8e: 0x56b4,
            0x9a8f: 0x56c2,
            0x9a90: 0x56bc,
            0x9a91: 0x56c1,
            0x9a92: 0x56c3,
            0x9a93: 0x56c0,
            0x9a94: 0x56c8,
            0x9a95: 0x56ce,
            0x9a96: 0x56d1,
            0x9a97: 0x56d3,
            0x9a98: 0x56d7,
            0x9a99: 0x56ee,
            0x9a9a: 0x56f9,
            0x9a9b: 0x5700,
            0x9a9c: 0x56ff,
            0x9a9d: 0x5704,
            0x9a9e: 0x5709,
            0x9a9f: 0x5708,
            0x9aa0: 0x570b,
            0x9aa1: 0x570d,
            0x9aa2: 0x5713,
            0x9aa3: 0x5718,
            0x9aa4: 0x5716,
            0x9aa5: 0x55c7,
            0x9aa6: 0x571c,
            0x9aa7: 0x5726,
            0x9aa8: 0x5737,
            0x9aa9: 0x5738,
            0x9aaa: 0x574e,
            0x9aab: 0x573b,
            0x9aac: 0x5740,
            0x9aad: 0x574f,
            0x9aae: 0x5769,
            0x9aaf: 0x57c0,
            0x9ab0: 0x5788,
            0x9ab1: 0x5761,
            0x9ab2: 0x577f,
            0x9ab3: 0x5789,
            0x9ab4: 0x5793,
            0x9ab5: 0x57a0,
            0x9ab6: 0x57b3,
            0x9ab7: 0x57a4,
            0x9ab8: 0x57aa,
            0x9ab9: 0x57b0,
            0x9aba: 0x57c3,
            0x9abb: 0x57c6,
            0x9abc: 0x57d4,
            0x9abd: 0x57d2,
            0x9abe: 0x57d3,
            0x9abf: 0x580a,
            0x9ac0: 0x57d6,
            0x9ac1: 0x57e3,
            0x9ac2: 0x580b,
            0x9ac3: 0x5819,
            0x9ac4: 0x581d,
            0x9ac5: 0x5872,
            0x9ac6: 0x5821,
            0x9ac7: 0x5862,
            0x9ac8: 0x584b,
            0x9ac9: 0x5870,
            0x9aca: 0x6bc0,
            0x9acb: 0x5852,
            0x9acc: 0x583d,
            0x9acd: 0x5879,
            0x9ace: 0x5885,
            0x9acf: 0x58b9,
            0x9ad0: 0x589f,
            0x9ad1: 0x58ab,
            0x9ad2: 0x58ba,
            0x9ad3: 0x58de,
            0x9ad4: 0x58bb,
            0x9ad5: 0x58b8,
            0x9ad6: 0x58ae,
            0x9ad7: 0x58c5,
            0x9ad8: 0x58d3,
            0x9ad9: 0x58d1,
            0x9ada: 0x58d7,
            0x9adb: 0x58d9,
            0x9adc: 0x58d8,
            0x9add: 0x58e5,
            0x9ade: 0x58dc,
            0x9adf: 0x58e4,
            0x9ae0: 0x58df,
            0x9ae1: 0x58ef,
            0x9ae2: 0x58fa,
            0x9ae3: 0x58f9,
            0x9ae4: 0x58fb,
            0x9ae5: 0x58fc,
            0x9ae6: 0x58fd,
            0x9ae7: 0x5902,
            0x9ae8: 0x590a,
            0x9ae9: 0x5910,
            0x9aea: 0x591b,
            0x9aeb: 0x68a6,
            0x9aec: 0x5925,
            0x9aed: 0x592c,
            0x9aee: 0x592d,
            0x9aef: 0x5932,
            0x9af0: 0x5938,
            0x9af1: 0x593e,
            0x9af2: 0x7ad2,
            0x9af3: 0x5955,
            0x9af4: 0x5950,
            0x9af5: 0x594e,
            0x9af6: 0x595a,
            0x9af7: 0x5958,
            0x9af8: 0x5962,
            0x9af9: 0x5960,
            0x9afa: 0x5967,
            0x9afb: 0x596c,
            0x9afc: 0x5969,
            0x9b40: 0x5978,
            0x9b41: 0x5981,
            0x9b42: 0x599d,
            0x9b43: 0x4f5e,
            0x9b44: 0x4fab,
            0x9b45: 0x59a3,
            0x9b46: 0x59b2,
            0x9b47: 0x59c6,
            0x9b48: 0x59e8,
            0x9b49: 0x59dc,
            0x9b4a: 0x598d,
            0x9b4b: 0x59d9,
            0x9b4c: 0x59da,
            0x9b4d: 0x5a25,
            0x9b4e: 0x5a1f,
            0x9b4f: 0x5a11,
            0x9b50: 0x5a1c,
            0x9b51: 0x5a09,
            0x9b52: 0x5a1a,
            0x9b53: 0x5a40,
            0x9b54: 0x5a6c,
            0x9b55: 0x5a49,
            0x9b56: 0x5a35,
            0x9b57: 0x5a36,
            0x9b58: 0x5a62,
            0x9b59: 0x5a6a,
            0x9b5a: 0x5a9a,
            0x9b5b: 0x5abc,
            0x9b5c: 0x5abe,
            0x9b5d: 0x5acb,
            0x9b5e: 0x5ac2,
            0x9b5f: 0x5abd,
            0x9b60: 0x5ae3,
            0x9b61: 0x5ad7,
            0x9b62: 0x5ae6,
            0x9b63: 0x5ae9,
            0x9b64: 0x5ad6,
            0x9b65: 0x5afa,
            0x9b66: 0x5afb,
            0x9b67: 0x5b0c,
            0x9b68: 0x5b0b,
            0x9b69: 0x5b16,
            0x9b6a: 0x5b32,
            0x9b6b: 0x5ad0,
            0x9b6c: 0x5b2a,
            0x9b6d: 0x5b36,
            0x9b6e: 0x5b3e,
            0x9b6f: 0x5b43,
            0x9b70: 0x5b45,
            0x9b71: 0x5b40,
            0x9b72: 0x5b51,
            0x9b73: 0x5b55,
            0x9b74: 0x5b5a,
            0x9b75: 0x5b5b,
            0x9b76: 0x5b65,
            0x9b77: 0x5b69,
            0x9b78: 0x5b70,
            0x9b79: 0x5b73,
            0x9b7a: 0x5b75,
            0x9b7b: 0x5b78,
            0x9b7c: 0x6588,
            0x9b7d: 0x5b7a,
            0x9b7e: 0x5b80,
            0x9b80: 0x5b83,
            0x9b81: 0x5ba6,
            0x9b82: 0x5bb8,
            0x9b83: 0x5bc3,
            0x9b84: 0x5bc7,
            0x9b85: 0x5bc9,
            0x9b86: 0x5bd4,
            0x9b87: 0x5bd0,
            0x9b88: 0x5be4,
            0x9b89: 0x5be6,
            0x9b8a: 0x5be2,
            0x9b8b: 0x5bde,
            0x9b8c: 0x5be5,
            0x9b8d: 0x5beb,
            0x9b8e: 0x5bf0,
            0x9b8f: 0x5bf6,
            0x9b90: 0x5bf3,
            0x9b91: 0x5c05,
            0x9b92: 0x5c07,
            0x9b93: 0x5c08,
            0x9b94: 0x5c0d,
            0x9b95: 0x5c13,
            0x9b96: 0x5c20,
            0x9b97: 0x5c22,
            0x9b98: 0x5c28,
            0x9b99: 0x5c38,
            0x9b9a: 0x5c39,
            0x9b9b: 0x5c41,
            0x9b9c: 0x5c46,
            0x9b9d: 0x5c4e,
            0x9b9e: 0x5c53,
            0x9b9f: 0x5c50,
            0x9ba0: 0x5c4f,
            0x9ba1: 0x5b71,
            0x9ba2: 0x5c6c,
            0x9ba3: 0x5c6e,
            0x9ba4: 0x4e62,
            0x9ba5: 0x5c76,
            0x9ba6: 0x5c79,
            0x9ba7: 0x5c8c,
            0x9ba8: 0x5c91,
            0x9ba9: 0x5c94,
            0x9baa: 0x599b,
            0x9bab: 0x5cab,
            0x9bac: 0x5cbb,
            0x9bad: 0x5cb6,
            0x9bae: 0x5cbc,
            0x9baf: 0x5cb7,
            0x9bb0: 0x5cc5,
            0x9bb1: 0x5cbe,
            0x9bb2: 0x5cc7,
            0x9bb3: 0x5cd9,
            0x9bb4: 0x5ce9,
            0x9bb5: 0x5cfd,
            0x9bb6: 0x5cfa,
            0x9bb7: 0x5ced,
            0x9bb8: 0x5d8c,
            0x9bb9: 0x5cea,
            0x9bba: 0x5d0b,
            0x9bbb: 0x5d15,
            0x9bbc: 0x5d17,
            0x9bbd: 0x5d5c,
            0x9bbe: 0x5d1f,
            0x9bbf: 0x5d1b,
            0x9bc0: 0x5d11,
            0x9bc1: 0x5d14,
            0x9bc2: 0x5d22,
            0x9bc3: 0x5d1a,
            0x9bc4: 0x5d19,
            0x9bc5: 0x5d18,
            0x9bc6: 0x5d4c,
            0x9bc7: 0x5d52,
            0x9bc8: 0x5d4e,
            0x9bc9: 0x5d4b,
            0x9bca: 0x5d6c,
            0x9bcb: 0x5d73,
            0x9bcc: 0x5d76,
            0x9bcd: 0x5d87,
            0x9bce: 0x5d84,
            0x9bcf: 0x5d82,
            0x9bd0: 0x5da2,
            0x9bd1: 0x5d9d,
            0x9bd2: 0x5dac,
            0x9bd3: 0x5dae,
            0x9bd4: 0x5dbd,
            0x9bd5: 0x5d90,
            0x9bd6: 0x5db7,
            0x9bd7: 0x5dbc,
            0x9bd8: 0x5dc9,
            0x9bd9: 0x5dcd,
            0x9bda: 0x5dd3,
            0x9bdb: 0x5dd2,
            0x9bdc: 0x5dd6,
            0x9bdd: 0x5ddb,
            0x9bde: 0x5deb,
            0x9bdf: 0x5df2,
            0x9be0: 0x5df5,
            0x9be1: 0x5e0b,
            0x9be2: 0x5e1a,
            0x9be3: 0x5e19,
            0x9be4: 0x5e11,
            0x9be5: 0x5e1b,
            0x9be6: 0x5e36,
            0x9be7: 0x5e37,
            0x9be8: 0x5e44,
            0x9be9: 0x5e43,
            0x9bea: 0x5e40,
            0x9beb: 0x5e4e,
            0x9bec: 0x5e57,
            0x9bed: 0x5e54,
            0x9bee: 0x5e5f,
            0x9bef: 0x5e62,
            0x9bf0: 0x5e64,
            0x9bf1: 0x5e47,
            0x9bf2: 0x5e75,
            0x9bf3: 0x5e76,
            0x9bf4: 0x5e7a,
            0x9bf5: 0x9ebc,
            0x9bf6: 0x5e7f,
            0x9bf7: 0x5ea0,
            0x9bf8: 0x5ec1,
            0x9bf9: 0x5ec2,
            0x9bfa: 0x5ec8,
            0x9bfb: 0x5ed0,
            0x9bfc: 0x5ecf,
            0x9c40: 0x5ed6,
            0x9c41: 0x5ee3,
            0x9c42: 0x5edd,
            0x9c43: 0x5eda,
            0x9c44: 0x5edb,
            0x9c45: 0x5ee2,
            0x9c46: 0x5ee1,
            0x9c47: 0x5ee8,
            0x9c48: 0x5ee9,
            0x9c49: 0x5eec,
            0x9c4a: 0x5ef1,
            0x9c4b: 0x5ef3,
            0x9c4c: 0x5ef0,
            0x9c4d: 0x5ef4,
            0x9c4e: 0x5ef8,
            0x9c4f: 0x5efe,
            0x9c50: 0x5f03,
            0x9c51: 0x5f09,
            0x9c52: 0x5f5d,
            0x9c53: 0x5f5c,
            0x9c54: 0x5f0b,
            0x9c55: 0x5f11,
            0x9c56: 0x5f16,
            0x9c57: 0x5f29,
            0x9c58: 0x5f2d,
            0x9c59: 0x5f38,
            0x9c5a: 0x5f41,
            0x9c5b: 0x5f48,
            0x9c5c: 0x5f4c,
            0x9c5d: 0x5f4e,
            0x9c5e: 0x5f2f,
            0x9c5f: 0x5f51,
            0x9c60: 0x5f56,
            0x9c61: 0x5f57,
            0x9c62: 0x5f59,
            0x9c63: 0x5f61,
            0x9c64: 0x5f6d,
            0x9c65: 0x5f73,
            0x9c66: 0x5f77,
            0x9c67: 0x5f83,
            0x9c68: 0x5f82,
            0x9c69: 0x5f7f,
            0x9c6a: 0x5f8a,
            0x9c6b: 0x5f88,
            0x9c6c: 0x5f91,
            0x9c6d: 0x5f87,
            0x9c6e: 0x5f9e,
            0x9c6f: 0x5f99,
            0x9c70: 0x5f98,
            0x9c71: 0x5fa0,
            0x9c72: 0x5fa8,
            0x9c73: 0x5fad,
            0x9c74: 0x5fbc,
            0x9c75: 0x5fd6,
            0x9c76: 0x5ffb,
            0x9c77: 0x5fe4,
            0x9c78: 0x5ff8,
            0x9c79: 0x5ff1,
            0x9c7a: 0x5fdd,
            0x9c7b: 0x60b3,
            0x9c7c: 0x5fff,
            0x9c7d: 0x6021,
            0x9c7e: 0x6060,
            0x9c80: 0x6019,
            0x9c81: 0x6010,
            0x9c82: 0x6029,
            0x9c83: 0x600e,
            0x9c84: 0x6031,
            0x9c85: 0x601b,
            0x9c86: 0x6015,
            0x9c87: 0x602b,
            0x9c88: 0x6026,
            0x9c89: 0x600f,
            0x9c8a: 0x603a,
            0x9c8b: 0x605a,
            0x9c8c: 0x6041,
            0x9c8d: 0x606a,
            0x9c8e: 0x6077,
            0x9c8f: 0x605f,
            0x9c90: 0x604a,
            0x9c91: 0x6046,
            0x9c92: 0x604d,
            0x9c93: 0x6063,
            0x9c94: 0x6043,
            0x9c95: 0x6064,
            0x9c96: 0x6042,
            0x9c97: 0x606c,
            0x9c98: 0x606b,
            0x9c99: 0x6059,
            0x9c9a: 0x6081,
            0x9c9b: 0x608d,
            0x9c9c: 0x60e7,
            0x9c9d: 0x6083,
            0x9c9e: 0x609a,
            0x9c9f: 0x6084,
            0x9ca0: 0x609b,
            0x9ca1: 0x6096,
            0x9ca2: 0x6097,
            0x9ca3: 0x6092,
            0x9ca4: 0x60a7,
            0x9ca5: 0x608b,
            0x9ca6: 0x60e1,
            0x9ca7: 0x60b8,
            0x9ca8: 0x60e0,
            0x9ca9: 0x60d3,
            0x9caa: 0x60b4,
            0x9cab: 0x5ff0,
            0x9cac: 0x60bd,
            0x9cad: 0x60c6,
            0x9cae: 0x60b5,
            0x9caf: 0x60d8,
            0x9cb0: 0x614d,
            0x9cb1: 0x6115,
            0x9cb2: 0x6106,
            0x9cb3: 0x60f6,
            0x9cb4: 0x60f7,
            0x9cb5: 0x6100,
            0x9cb6: 0x60f4,
            0x9cb7: 0x60fa,
            0x9cb8: 0x6103,
            0x9cb9: 0x6121,
            0x9cba: 0x60fb,
            0x9cbb: 0x60f1,
            0x9cbc: 0x610d,
            0x9cbd: 0x610e,
            0x9cbe: 0x6147,
            0x9cbf: 0x613e,
            0x9cc0: 0x6128,
            0x9cc1: 0x6127,
            0x9cc2: 0x614a,
            0x9cc3: 0x613f,
            0x9cc4: 0x613c,
            0x9cc5: 0x612c,
            0x9cc6: 0x6134,
            0x9cc7: 0x613d,
            0x9cc8: 0x6142,
            0x9cc9: 0x6144,
            0x9cca: 0x6173,
            0x9ccb: 0x6177,
            0x9ccc: 0x6158,
            0x9ccd: 0x6159,
            0x9cce: 0x615a,
            0x9ccf: 0x616b,
            0x9cd0: 0x6174,
            0x9cd1: 0x616f,
            0x9cd2: 0x6165,
            0x9cd3: 0x6171,
            0x9cd4: 0x615f,
            0x9cd5: 0x615d,
            0x9cd6: 0x6153,
            0x9cd7: 0x6175,
            0x9cd8: 0x6199,
            0x9cd9: 0x6196,
            0x9cda: 0x6187,
            0x9cdb: 0x61ac,
            0x9cdc: 0x6194,
            0x9cdd: 0x619a,
            0x9cde: 0x618a,
            0x9cdf: 0x6191,
            0x9ce0: 0x61ab,
            0x9ce1: 0x61ae,
            0x9ce2: 0x61cc,
            0x9ce3: 0x61ca,
            0x9ce4: 0x61c9,
            0x9ce5: 0x61f7,
            0x9ce6: 0x61c8,
            0x9ce7: 0x61c3,
            0x9ce8: 0x61c6,
            0x9ce9: 0x61ba,
            0x9cea: 0x61cb,
            0x9ceb: 0x7f79,
            0x9cec: 0x61cd,
            0x9ced: 0x61e6,
            0x9cee: 0x61e3,
            0x9cef: 0x61f6,
            0x9cf0: 0x61fa,
            0x9cf1: 0x61f4,
            0x9cf2: 0x61ff,
            0x9cf3: 0x61fd,
            0x9cf4: 0x61fc,
            0x9cf5: 0x61fe,
            0x9cf6: 0x6200,
            0x9cf7: 0x6208,
            0x9cf8: 0x6209,
            0x9cf9: 0x620d,
            0x9cfa: 0x620c,
            0x9cfb: 0x6214,
            0x9cfc: 0x621b,
            0x9d40: 0x621e,
            0x9d41: 0x6221,
            0x9d42: 0x622a,
            0x9d43: 0x622e,
            0x9d44: 0x6230,
            0x9d45: 0x6232,
            0x9d46: 0x6233,
            0x9d47: 0x6241,
            0x9d48: 0x624e,
            0x9d49: 0x625e,
            0x9d4a: 0x6263,
            0x9d4b: 0x625b,
            0x9d4c: 0x6260,
            0x9d4d: 0x6268,
            0x9d4e: 0x627c,
            0x9d4f: 0x6282,
            0x9d50: 0x6289,
            0x9d51: 0x627e,
            0x9d52: 0x6292,
            0x9d53: 0x6293,
            0x9d54: 0x6296,
            0x9d55: 0x62d4,
            0x9d56: 0x6283,
            0x9d57: 0x6294,
            0x9d58: 0x62d7,
            0x9d59: 0x62d1,
            0x9d5a: 0x62bb,
            0x9d5b: 0x62cf,
            0x9d5c: 0x62ff,
            0x9d5d: 0x62c6,
            0x9d5e: 0x64d4,
            0x9d5f: 0x62c8,
            0x9d60: 0x62dc,
            0x9d61: 0x62cc,
            0x9d62: 0x62ca,
            0x9d63: 0x62c2,
            0x9d64: 0x62c7,
            0x9d65: 0x629b,
            0x9d66: 0x62c9,
            0x9d67: 0x630c,
            0x9d68: 0x62ee,
            0x9d69: 0x62f1,
            0x9d6a: 0x6327,
            0x9d6b: 0x6302,
            0x9d6c: 0x6308,
            0x9d6d: 0x62ef,
            0x9d6e: 0x62f5,
            0x9d6f: 0x6350,
            0x9d70: 0x633e,
            0x9d71: 0x634d,
            0x9d72: 0x641c,
            0x9d73: 0x634f,
            0x9d74: 0x6396,
            0x9d75: 0x638e,
            0x9d76: 0x6380,
            0x9d77: 0x63ab,
            0x9d78: 0x6376,
            0x9d79: 0x63a3,
            0x9d7a: 0x638f,
            0x9d7b: 0x6389,
            0x9d7c: 0x639f,
            0x9d7d: 0x63b5,
            0x9d7e: 0x636b,
            0x9d80: 0x6369,
            0x9d81: 0x63be,
            0x9d82: 0x63e9,
            0x9d83: 0x63c0,
            0x9d84: 0x63c6,
            0x9d85: 0x63e3,
            0x9d86: 0x63c9,
            0x9d87: 0x63d2,
            0x9d88: 0x63f6,
            0x9d89: 0x63c4,
            0x9d8a: 0x6416,
            0x9d8b: 0x6434,
            0x9d8c: 0x6406,
            0x9d8d: 0x6413,
            0x9d8e: 0x6426,
            0x9d8f: 0x6436,
            0x9d90: 0x651d,
            0x9d91: 0x6417,
            0x9d92: 0x6428,
            0x9d93: 0x640f,
            0x9d94: 0x6467,
            0x9d95: 0x646f,
            0x9d96: 0x6476,
            0x9d97: 0x644e,
            0x9d98: 0x652a,
            0x9d99: 0x6495,
            0x9d9a: 0x6493,
            0x9d9b: 0x64a5,
            0x9d9c: 0x64a9,
            0x9d9d: 0x6488,
            0x9d9e: 0x64bc,
            0x9d9f: 0x64da,
            0x9da0: 0x64d2,
            0x9da1: 0x64c5,
            0x9da2: 0x64c7,
            0x9da3: 0x64bb,
            0x9da4: 0x64d8,
            0x9da5: 0x64c2,
            0x9da6: 0x64f1,
            0x9da7: 0x64e7,
            0x9da8: 0x8209,
            0x9da9: 0x64e0,
            0x9daa: 0x64e1,
            0x9dab: 0x62ac,
            0x9dac: 0x64e3,
            0x9dad: 0x64ef,
            0x9dae: 0x652c,
            0x9daf: 0x64f6,
            0x9db0: 0x64f4,
            0x9db1: 0x64f2,
            0x9db2: 0x64fa,
            0x9db3: 0x6500,
            0x9db4: 0x64fd,
            0x9db5: 0x6518,
            0x9db6: 0x651c,
            0x9db7: 0x6505,
            0x9db8: 0x6524,
            0x9db9: 0x6523,
            0x9dba: 0x652b,
            0x9dbb: 0x6534,
            0x9dbc: 0x6535,
            0x9dbd: 0x6537,
            0x9dbe: 0x6536,
            0x9dbf: 0x6538,
            0x9dc0: 0x754b,
            0x9dc1: 0x6548,
            0x9dc2: 0x6556,
            0x9dc3: 0x6555,
            0x9dc4: 0x654d,
            0x9dc5: 0x6558,
            0x9dc6: 0x655e,
            0x9dc7: 0x655d,
            0x9dc8: 0x6572,
            0x9dc9: 0x6578,
            0x9dca: 0x6582,
            0x9dcb: 0x6583,
            0x9dcc: 0x8b8a,
            0x9dcd: 0x659b,
            0x9dce: 0x659f,
            0x9dcf: 0x65ab,
            0x9dd0: 0x65b7,
            0x9dd1: 0x65c3,
            0x9dd2: 0x65c6,
            0x9dd3: 0x65c1,
            0x9dd4: 0x65c4,
            0x9dd5: 0x65cc,
            0x9dd6: 0x65d2,
            0x9dd7: 0x65db,
            0x9dd8: 0x65d9,
            0x9dd9: 0x65e0,
            0x9dda: 0x65e1,
            0x9ddb: 0x65f1,
            0x9ddc: 0x6772,
            0x9ddd: 0x660a,
            0x9dde: 0x6603,
            0x9ddf: 0x65fb,
            0x9de0: 0x6773,
            0x9de1: 0x6635,
            0x9de2: 0x6636,
            0x9de3: 0x6634,
            0x9de4: 0x661c,
            0x9de5: 0x664f,
            0x9de6: 0x6644,
            0x9de7: 0x6649,
            0x9de8: 0x6641,
            0x9de9: 0x665e,
            0x9dea: 0x665d,
            0x9deb: 0x6664,
            0x9dec: 0x6667,
            0x9ded: 0x6668,
            0x9dee: 0x665f,
            0x9def: 0x6662,
            0x9df0: 0x6670,
            0x9df1: 0x6683,
            0x9df2: 0x6688,
            0x9df3: 0x668e,
            0x9df4: 0x6689,
            0x9df5: 0x6684,
            0x9df6: 0x6698,
            0x9df7: 0x669d,
            0x9df8: 0x66c1,
            0x9df9: 0x66b9,
            0x9dfa: 0x66c9,
            0x9dfb: 0x66be,
            0x9dfc: 0x66bc,
            0x9e40: 0x66c4,
            0x9e41: 0x66b8,
            0x9e42: 0x66d6,
            0x9e43: 0x66da,
            0x9e44: 0x66e0,
            0x9e45: 0x663f,
            0x9e46: 0x66e6,
            0x9e47: 0x66e9,
            0x9e48: 0x66f0,
            0x9e49: 0x66f5,
            0x9e4a: 0x66f7,
            0x9e4b: 0x670f,
            0x9e4c: 0x6716,
            0x9e4d: 0x671e,
            0x9e4e: 0x6726,
            0x9e4f: 0x6727,
            0x9e50: 0x9738,
            0x9e51: 0x672e,
            0x9e52: 0x673f,
            0x9e53: 0x6736,
            0x9e54: 0x6741,
            0x9e55: 0x6738,
            0x9e56: 0x6737,
            0x9e57: 0x6746,
            0x9e58: 0x675e,
            0x9e59: 0x6760,
            0x9e5a: 0x6759,
            0x9e5b: 0x6763,
            0x9e5c: 0x6764,
            0x9e5d: 0x6789,
            0x9e5e: 0x6770,
            0x9e5f: 0x67a9,
            0x9e60: 0x677c,
            0x9e61: 0x676a,
            0x9e62: 0x678c,
            0x9e63: 0x678b,
            0x9e64: 0x67a6,
            0x9e65: 0x67a1,
            0x9e66: 0x6785,
            0x9e67: 0x67b7,
            0x9e68: 0x67ef,
            0x9e69: 0x67b4,
            0x9e6a: 0x67ec,
            0x9e6b: 0x67b3,
            0x9e6c: 0x67e9,
            0x9e6d: 0x67b8,
            0x9e6e: 0x67e4,
            0x9e6f: 0x67de,
            0x9e70: 0x67dd,
            0x9e71: 0x67e2,
            0x9e72: 0x67ee,
            0x9e73: 0x67b9,
            0x9e74: 0x67ce,
            0x9e75: 0x67c6,
            0x9e76: 0x67e7,
            0x9e77: 0x6a9c,
            0x9e78: 0x681e,
            0x9e79: 0x6846,
            0x9e7a: 0x6829,
            0x9e7b: 0x6840,
            0x9e7c: 0x684d,
            0x9e7d: 0x6832,
            0x9e7e: 0x684e,
            0x9e80: 0x68b3,
            0x9e81: 0x682b,
            0x9e82: 0x6859,
            0x9e83: 0x6863,
            0x9e84: 0x6877,
            0x9e85: 0x687f,
            0x9e86: 0x689f,
            0x9e87: 0x688f,
            0x9e88: 0x68ad,
            0x9e89: 0x6894,
            0x9e8a: 0x689d,
            0x9e8b: 0x689b,
            0x9e8c: 0x6883,
            0x9e8d: 0x6aae,
            0x9e8e: 0x68b9,
            0x9e8f: 0x6874,
            0x9e90: 0x68b5,
            0x9e91: 0x68a0,
            0x9e92: 0x68ba,
            0x9e93: 0x690f,
            0x9e94: 0x688d,
            0x9e95: 0x687e,
            0x9e96: 0x6901,
            0x9e97: 0x68ca,
            0x9e98: 0x6908,
            0x9e99: 0x68d8,
            0x9e9a: 0x6922,
            0x9e9b: 0x6926,
            0x9e9c: 0x68e1,
            0x9e9d: 0x690c,
            0x9e9e: 0x68cd,
            0x9e9f: 0x68d4,
            0x9ea0: 0x68e7,
            0x9ea1: 0x68d5,
            0x9ea2: 0x6936,
            0x9ea3: 0x6912,
            0x9ea4: 0x6904,
            0x9ea5: 0x68d7,
            0x9ea6: 0x68e3,
            0x9ea7: 0x6925,
            0x9ea8: 0x68f9,
            0x9ea9: 0x68e0,
            0x9eaa: 0x68ef,
            0x9eab: 0x6928,
            0x9eac: 0x692a,
            0x9ead: 0x691a,
            0x9eae: 0x6923,
            0x9eaf: 0x6921,
            0x9eb0: 0x68c6,
            0x9eb1: 0x6979,
            0x9eb2: 0x6977,
            0x9eb3: 0x695c,
            0x9eb4: 0x6978,
            0x9eb5: 0x696b,
            0x9eb6: 0x6954,
            0x9eb7: 0x697e,
            0x9eb8: 0x696e,
            0x9eb9: 0x6939,
            0x9eba: 0x6974,
            0x9ebb: 0x693d,
            0x9ebc: 0x6959,
            0x9ebd: 0x6930,
            0x9ebe: 0x6961,
            0x9ebf: 0x695e,
            0x9ec0: 0x695d,
            0x9ec1: 0x6981,
            0x9ec2: 0x696a,
            0x9ec3: 0x69b2,
            0x9ec4: 0x69ae,
            0x9ec5: 0x69d0,
            0x9ec6: 0x69bf,
            0x9ec7: 0x69c1,
            0x9ec8: 0x69d3,
            0x9ec9: 0x69be,
            0x9eca: 0x69ce,
            0x9ecb: 0x5be8,
            0x9ecc: 0x69ca,
            0x9ecd: 0x69dd,
            0x9ece: 0x69bb,
            0x9ecf: 0x69c3,
            0x9ed0: 0x69a7,
            0x9ed1: 0x6a2e,
            0x9ed2: 0x6991,
            0x9ed3: 0x69a0,
            0x9ed4: 0x699c,
            0x9ed5: 0x6995,
            0x9ed6: 0x69b4,
            0x9ed7: 0x69de,
            0x9ed8: 0x69e8,
            0x9ed9: 0x6a02,
            0x9eda: 0x6a1b,
            0x9edb: 0x69ff,
            0x9edc: 0x6b0a,
            0x9edd: 0x69f9,
            0x9ede: 0x69f2,
            0x9edf: 0x69e7,
            0x9ee0: 0x6a05,
            0x9ee1: 0x69b1,
            0x9ee2: 0x6a1e,
            0x9ee3: 0x69ed,
            0x9ee4: 0x6a14,
            0x9ee5: 0x69eb,
            0x9ee6: 0x6a0a,
            0x9ee7: 0x6a12,
            0x9ee8: 0x6ac1,
            0x9ee9: 0x6a23,
            0x9eea: 0x6a13,
            0x9eeb: 0x6a44,
            0x9eec: 0x6a0c,
            0x9eed: 0x6a72,
            0x9eee: 0x6a36,
            0x9eef: 0x6a78,
            0x9ef0: 0x6a47,
            0x9ef1: 0x6a62,
            0x9ef2: 0x6a59,
            0x9ef3: 0x6a66,
            0x9ef4: 0x6a48,
            0x9ef5: 0x6a38,
            0x9ef6: 0x6a22,
            0x9ef7: 0x6a90,
            0x9ef8: 0x6a8d,
            0x9ef9: 0x6aa0,
            0x9efa: 0x6a84,
            0x9efb: 0x6aa2,
            0x9efc: 0x6aa3,
            0x9f40: 0x6a97,
            0x9f41: 0x8617,
            0x9f42: 0x6abb,
            0x9f43: 0x6ac3,
            0x9f44: 0x6ac2,
            0x9f45: 0x6ab8,
            0x9f46: 0x6ab3,
            0x9f47: 0x6aac,
            0x9f48: 0x6ade,
            0x9f49: 0x6ad1,
            0x9f4a: 0x6adf,
            0x9f4b: 0x6aaa,
            0x9f4c: 0x6ada,
            0x9f4d: 0x6aea,
            0x9f4e: 0x6afb,
            0x9f4f: 0x6b05,
            0x9f50: 0x8616,
            0x9f51: 0x6afa,
            0x9f52: 0x6b12,
            0x9f53: 0x6b16,
            0x9f54: 0x9b31,
            0x9f55: 0x6b1f,
            0x9f56: 0x6b38,
            0x9f57: 0x6b37,
            0x9f58: 0x76dc,
            0x9f59: 0x6b39,
            0x9f5a: 0x98ee,
            0x9f5b: 0x6b47,
            0x9f5c: 0x6b43,
            0x9f5d: 0x6b49,
            0x9f5e: 0x6b50,
            0x9f5f: 0x6b59,
            0x9f60: 0x6b54,
            0x9f61: 0x6b5b,
            0x9f62: 0x6b5f,
            0x9f63: 0x6b61,
            0x9f64: 0x6b78,
            0x9f65: 0x6b79,
            0x9f66: 0x6b7f,
            0x9f67: 0x6b80,
            0x9f68: 0x6b84,
            0x9f69: 0x6b83,
            0x9f6a: 0x6b8d,
            0x9f6b: 0x6b98,
            0x9f6c: 0x6b95,
            0x9f6d: 0x6b9e,
            0x9f6e: 0x6ba4,
            0x9f6f: 0x6baa,
            0x9f70: 0x6bab,
            0x9f71: 0x6baf,
            0x9f72: 0x6bb2,
            0x9f73: 0x6bb1,
            0x9f74: 0x6bb3,
            0x9f75: 0x6bb7,
            0x9f76: 0x6bbc,
            0x9f77: 0x6bc6,
            0x9f78: 0x6bcb,
            0x9f79: 0x6bd3,
            0x9f7a: 0x6bdf,
            0x9f7b: 0x6bec,
            0x9f7c: 0x6beb,
            0x9f7d: 0x6bf3,
            0x9f7e: 0x6bef,
            0x9f80: 0x9ebe,
            0x9f81: 0x6c08,
            0x9f82: 0x6c13,
            0x9f83: 0x6c14,
            0x9f84: 0x6c1b,
            0x9f85: 0x6c24,
            0x9f86: 0x6c23,
            0x9f87: 0x6c5e,
            0x9f88: 0x6c55,
            0x9f89: 0x6c62,
            0x9f8a: 0x6c6a,
            0x9f8b: 0x6c82,
            0x9f8c: 0x6c8d,
            0x9f8d: 0x6c9a,
            0x9f8e: 0x6c81,
            0x9f8f: 0x6c9b,
            0x9f90: 0x6c7e,
            0x9f91: 0x6c68,
            0x9f92: 0x6c73,
            0x9f93: 0x6c92,
            0x9f94: 0x6c90,
            0x9f95: 0x6cc4,
            0x9f96: 0x6cf1,
            0x9f97: 0x6cd3,
            0x9f98: 0x6cbd,
            0x9f99: 0x6cd7,
            0x9f9a: 0x6cc5,
            0x9f9b: 0x6cdd,
            0x9f9c: 0x6cae,
            0x9f9d: 0x6cb1,
            0x9f9e: 0x6cbe,
            0x9f9f: 0x6cba,
            0x9fa0: 0x6cdb,
            0x9fa1: 0x6cef,
            0x9fa2: 0x6cd9,
            0x9fa3: 0x6cea,
            0x9fa4: 0x6d1f,
            0x9fa5: 0x884d,
            0x9fa6: 0x6d36,
            0x9fa7: 0x6d2b,
            0x9fa8: 0x6d3d,
            0x9fa9: 0x6d38,
            0x9faa: 0x6d19,
            0x9fab: 0x6d35,
            0x9fac: 0x6d33,
            0x9fad: 0x6d12,
            0x9fae: 0x6d0c,
            0x9faf: 0x6d63,
            0x9fb0: 0x6d93,
            0x9fb1: 0x6d64,
            0x9fb2: 0x6d5a,
            0x9fb3: 0x6d79,
            0x9fb4: 0x6d59,
            0x9fb5: 0x6d8e,
            0x9fb6: 0x6d95,
            0x9fb7: 0x6fe4,
            0x9fb8: 0x6d85,
            0x9fb9: 0x6df9,
            0x9fba: 0x6e15,
            0x9fbb: 0x6e0a,
            0x9fbc: 0x6db5,
            0x9fbd: 0x6dc7,
            0x9fbe: 0x6de6,
            0x9fbf: 0x6db8,
            0x9fc0: 0x6dc6,
            0x9fc1: 0x6dec,
            0x9fc2: 0x6dde,
            0x9fc3: 0x6dcc,
            0x9fc4: 0x6de8,
            0x9fc5: 0x6dd2,
            0x9fc6: 0x6dc5,
            0x9fc7: 0x6dfa,
            0x9fc8: 0x6dd9,
            0x9fc9: 0x6de4,
            0x9fca: 0x6dd5,
            0x9fcb: 0x6dea,
            0x9fcc: 0x6dee,
            0x9fcd: 0x6e2d,
            0x9fce: 0x6e6e,
            0x9fcf: 0x6e2e,
            0x9fd0: 0x6e19,
            0x9fd1: 0x6e72,
            0x9fd2: 0x6e5f,
            0x9fd3: 0x6e3e,
            0x9fd4: 0x6e23,
            0x9fd5: 0x6e6b,
            0x9fd6: 0x6e2b,
            0x9fd7: 0x6e76,
            0x9fd8: 0x6e4d,
            0x9fd9: 0x6e1f,
            0x9fda: 0x6e43,
            0x9fdb: 0x6e3a,
            0x9fdc: 0x6e4e,
            0x9fdd: 0x6e24,
            0x9fde: 0x6eff,
            0x9fdf: 0x6e1d,
            0x9fe0: 0x6e38,
            0x9fe1: 0x6e82,
            0x9fe2: 0x6eaa,
            0x9fe3: 0x6e98,
            0x9fe4: 0x6ec9,
            0x9fe5: 0x6eb7,
            0x9fe6: 0x6ed3,
            0x9fe7: 0x6ebd,
            0x9fe8: 0x6eaf,
            0x9fe9: 0x6ec4,
            0x9fea: 0x6eb2,
            0x9feb: 0x6ed4,
            0x9fec: 0x6ed5,
            0x9fed: 0x6e8f,
            0x9fee: 0x6ea5,
            0x9fef: 0x6ec2,
            0x9ff0: 0x6e9f,
            0x9ff1: 0x6f41,
            0x9ff2: 0x6f11,
            0x9ff3: 0x704c,
            0x9ff4: 0x6eec,
            0x9ff5: 0x6ef8,
            0x9ff6: 0x6efe,
            0x9ff7: 0x6f3f,
            0x9ff8: 0x6ef2,
            0x9ff9: 0x6f31,
            0x9ffa: 0x6eef,
            0x9ffb: 0x6f32,
            0x9ffc: 0x6ecc,
            0xa1: 0xff61,
            0xa2: 0xff62,
            0xa3: 0xff63,
            0xa4: 0xff64,
            0xa5: 0xff65,
            0xa6: 0xff66,
            0xa7: 0xff67,
            0xa8: 0xff68,
            0xa9: 0xff69,
            0xaa: 0xff6a,
            0xab: 0xff6b,
            0xac: 0xff6c,
            0xad: 0xff6d,
            0xae: 0xff6e,
            0xaf: 0xff6f,
            0xb0: 0xff70,
            0xb1: 0xff71,
            0xb2: 0xff72,
            0xb3: 0xff73,
            0xb4: 0xff74,
            0xb5: 0xff75,
            0xb6: 0xff76,
            0xb7: 0xff77,
            0xb8: 0xff78,
            0xb9: 0xff79,
            0xba: 0xff7a,
            0xbb: 0xff7b,
            0xbc: 0xff7c,
            0xbd: 0xff7d,
            0xbe: 0xff7e,
            0xbf: 0xff7f,
            0xc0: 0xff80,
            0xc1: 0xff81,
            0xc2: 0xff82,
            0xc3: 0xff83,
            0xc4: 0xff84,
            0xc5: 0xff85,
            0xc6: 0xff86,
            0xc7: 0xff87,
            0xc8: 0xff88,
            0xc9: 0xff89,
            0xca: 0xff8a,
            0xcb: 0xff8b,
            0xcc: 0xff8c,
            0xcd: 0xff8d,
            0xce: 0xff8e,
            0xcf: 0xff8f,
            0xd0: 0xff90,
            0xd1: 0xff91,
            0xd2: 0xff92,
            0xd3: 0xff93,
            0xd4: 0xff94,
            0xd5: 0xff95,
            0xd6: 0xff96,
            0xd7: 0xff97,
            0xd8: 0xff98,
            0xd9: 0xff99,
            0xda: 0xff9a,
            0xdb: 0xff9b,
            0xdc: 0xff9c,
            0xdd: 0xff9d,
            0xde: 0xff9e,
            0xdf: 0xff9f,
            0xe040: 0x6f3e,
            0xe041: 0x6f13,
            0xe042: 0x6ef7,
            0xe043: 0x6f86,
            0xe044: 0x6f7a,
            0xe045: 0x6f78,
            0xe046: 0x6f81,
            0xe047: 0x6f80,
            0xe048: 0x6f6f,
            0xe049: 0x6f5b,
            0xe04a: 0x6ff3,
            0xe04b: 0x6f6d,
            0xe04c: 0x6f82,
            0xe04d: 0x6f7c,
            0xe04e: 0x6f58,
            0xe04f: 0x6f8e,
            0xe050: 0x6f91,
            0xe051: 0x6fc2,
            0xe052: 0x6f66,
            0xe053: 0x6fb3,
            0xe054: 0x6fa3,
            0xe055: 0x6fa1,
            0xe056: 0x6fa4,
            0xe057: 0x6fb9,
            0xe058: 0x6fc6,
            0xe059: 0x6faa,
            0xe05a: 0x6fdf,
            0xe05b: 0x6fd5,
            0xe05c: 0x6fec,
            0xe05d: 0x6fd4,
            0xe05e: 0x6fd8,
            0xe05f: 0x6ff1,
            0xe060: 0x6fee,
            0xe061: 0x6fdb,
            0xe062: 0x7009,
            0xe063: 0x700b,
            0xe064: 0x6ffa,
            0xe065: 0x7011,
            0xe066: 0x7001,
            0xe067: 0x700f,
            0xe068: 0x6ffe,
            0xe069: 0x701b,
            0xe06a: 0x701a,
            0xe06b: 0x6f74,
            0xe06c: 0x701d,
            0xe06d: 0x7018,
            0xe06e: 0x701f,
            0xe06f: 0x7030,
            0xe070: 0x703e,
            0xe071: 0x7032,
            0xe072: 0x7051,
            0xe073: 0x7063,
            0xe074: 0x7099,
            0xe075: 0x7092,
            0xe076: 0x70af,
            0xe077: 0x70f1,
            0xe078: 0x70ac,
            0xe079: 0x70b8,
            0xe07a: 0x70b3,
            0xe07b: 0x70ae,
            0xe07c: 0x70df,
            0xe07d: 0x70cb,
            0xe07e: 0x70dd,
            0xe080: 0x70d9,
            0xe081: 0x7109,
            0xe082: 0x70fd,
            0xe083: 0x711c,
            0xe084: 0x7119,
            0xe085: 0x7165,
            0xe086: 0x7155,
            0xe087: 0x7188,
            0xe088: 0x7166,
            0xe089: 0x7162,
            0xe08a: 0x714c,
            0xe08b: 0x7156,
            0xe08c: 0x716c,
            0xe08d: 0x718f,
            0xe08e: 0x71fb,
            0xe08f: 0x7184,
            0xe090: 0x7195,
            0xe091: 0x71a8,
            0xe092: 0x71ac,
            0xe093: 0x71d7,
            0xe094: 0x71b9,
            0xe095: 0x71be,
            0xe096: 0x71d2,
            0xe097: 0x71c9,
            0xe098: 0x71d4,
            0xe099: 0x71ce,
            0xe09a: 0x71e0,
            0xe09b: 0x71ec,
            0xe09c: 0x71e7,
            0xe09d: 0x71f5,
            0xe09e: 0x71fc,
            0xe09f: 0x71f9,
            0xe0a0: 0x71ff,
            0xe0a1: 0x720d,
            0xe0a2: 0x7210,
            0xe0a3: 0x721b,
            0xe0a4: 0x7228,
            0xe0a5: 0x722d,
            0xe0a6: 0x722c,
            0xe0a7: 0x7230,
            0xe0a8: 0x7232,
            0xe0a9: 0x723b,
            0xe0aa: 0x723c,
            0xe0ab: 0x723f,
            0xe0ac: 0x7240,
            0xe0ad: 0x7246,
            0xe0ae: 0x724b,
            0xe0af: 0x7258,
            0xe0b0: 0x7274,
            0xe0b1: 0x727e,
            0xe0b2: 0x7282,
            0xe0b3: 0x7281,
            0xe0b4: 0x7287,
            0xe0b5: 0x7292,
            0xe0b6: 0x7296,
            0xe0b7: 0x72a2,
            0xe0b8: 0x72a7,
            0xe0b9: 0x72b9,
            0xe0ba: 0x72b2,
            0xe0bb: 0x72c3,
            0xe0bc: 0x72c6,
            0xe0bd: 0x72c4,
            0xe0be: 0x72ce,
            0xe0bf: 0x72d2,
            0xe0c0: 0x72e2,
            0xe0c1: 0x72e0,
            0xe0c2: 0x72e1,
            0xe0c3: 0x72f9,
            0xe0c4: 0x72f7,
            0xe0c5: 0x500f,
            0xe0c6: 0x7317,
            0xe0c7: 0x730a,
            0xe0c8: 0x731c,
            0xe0c9: 0x7316,
            0xe0ca: 0x731d,
            0xe0cb: 0x7334,
            0xe0cc: 0x732f,
            0xe0cd: 0x7329,
            0xe0ce: 0x7325,
            0xe0cf: 0x733e,
            0xe0d0: 0x734e,
            0xe0d1: 0x734f,
            0xe0d2: 0x9ed8,
            0xe0d3: 0x7357,
            0xe0d4: 0x736a,
            0xe0d5: 0x7368,
            0xe0d6: 0x7370,
            0xe0d7: 0x7378,
            0xe0d8: 0x7375,
            0xe0d9: 0x737b,
            0xe0da: 0x737a,
            0xe0db: 0x73c8,
            0xe0dc: 0x73b3,
            0xe0dd: 0x73ce,
            0xe0de: 0x73bb,
            0xe0df: 0x73c0,
            0xe0e0: 0x73e5,
            0xe0e1: 0x73ee,
            0xe0e2: 0x73de,
            0xe0e3: 0x74a2,
            0xe0e4: 0x7405,
            0xe0e5: 0x746f,
            0xe0e6: 0x7425,
            0xe0e7: 0x73f8,
            0xe0e8: 0x7432,
            0xe0e9: 0x743a,
            0xe0ea: 0x7455,
            0xe0eb: 0x743f,
            0xe0ec: 0x745f,
            0xe0ed: 0x7459,
            0xe0ee: 0x7441,
            0xe0ef: 0x745c,
            0xe0f0: 0x7469,
            0xe0f1: 0x7470,
            0xe0f2: 0x7463,
            0xe0f3: 0x746a,
            0xe0f4: 0x7476,
            0xe0f5: 0x747e,
            0xe0f6: 0x748b,
            0xe0f7: 0x749e,
            0xe0f8: 0x74a7,
            0xe0f9: 0x74ca,
            0xe0fa: 0x74cf,
            0xe0fb: 0x74d4,
            0xe0fc: 0x73f1,
            0xe140: 0x74e0,
            0xe141: 0x74e3,
            0xe142: 0x74e7,
            0xe143: 0x74e9,
            0xe144: 0x74ee,
            0xe145: 0x74f2,
            0xe146: 0x74f0,
            0xe147: 0x74f1,
            0xe148: 0x74f8,
            0xe149: 0x74f7,
            0xe14a: 0x7504,
            0xe14b: 0x7503,
            0xe14c: 0x7505,
            0xe14d: 0x750c,
            0xe14e: 0x750e,
            0xe14f: 0x750d,
            0xe150: 0x7515,
            0xe151: 0x7513,
            0xe152: 0x751e,
            0xe153: 0x7526,
            0xe154: 0x752c,
            0xe155: 0x753c,
            0xe156: 0x7544,
            0xe157: 0x754d,
            0xe158: 0x754a,
            0xe159: 0x7549,
            0xe15a: 0x755b,
            0xe15b: 0x7546,
            0xe15c: 0x755a,
            0xe15d: 0x7569,
            0xe15e: 0x7564,
            0xe15f: 0x7567,
            0xe160: 0x756b,
            0xe161: 0x756d,
            0xe162: 0x7578,
            0xe163: 0x7576,
            0xe164: 0x7586,
            0xe165: 0x7587,
            0xe166: 0x7574,
            0xe167: 0x758a,
            0xe168: 0x7589,
            0xe169: 0x7582,
            0xe16a: 0x7594,
            0xe16b: 0x759a,
            0xe16c: 0x759d,
            0xe16d: 0x75a5,
            0xe16e: 0x75a3,
            0xe16f: 0x75c2,
            0xe170: 0x75b3,
            0xe171: 0x75c3,
            0xe172: 0x75b5,
            0xe173: 0x75bd,
            0xe174: 0x75b8,
            0xe175: 0x75bc,
            0xe176: 0x75b1,
            0xe177: 0x75cd,
            0xe178: 0x75ca,
            0xe179: 0x75d2,
            0xe17a: 0x75d9,
            0xe17b: 0x75e3,
            0xe17c: 0x75de,
            0xe17d: 0x75fe,
            0xe17e: 0x75ff,
            0xe180: 0x75fc,
            0xe181: 0x7601,
            0xe182: 0x75f0,
            0xe183: 0x75fa,
            0xe184: 0x75f2,
            0xe185: 0x75f3,
            0xe186: 0x760b,
            0xe187: 0x760d,
            0xe188: 0x7609,
            0xe189: 0x761f,
            0xe18a: 0x7627,
            0xe18b: 0x7620,
            0xe18c: 0x7621,
            0xe18d: 0x7622,
            0xe18e: 0x7624,
            0xe18f: 0x7634,
            0xe190: 0x7630,
            0xe191: 0x763b,
            0xe192: 0x7647,
            0xe193: 0x7648,
            0xe194: 0x7646,
            0xe195: 0x765c,
            0xe196: 0x7658,
            0xe197: 0x7661,
            0xe198: 0x7662,
            0xe199: 0x7668,
            0xe19a: 0x7669,
            0xe19b: 0x766a,
            0xe19c: 0x7667,
            0xe19d: 0x766c,
            0xe19e: 0x7670,
            0xe19f: 0x7672,
            0xe1a0: 0x7676,
            0xe1a1: 0x7678,
            0xe1a2: 0x767c,
            0xe1a3: 0x7680,
            0xe1a4: 0x7683,
            0xe1a5: 0x7688,
            0xe1a6: 0x768b,
            0xe1a7: 0x768e,
            0xe1a8: 0x7696,
            0xe1a9: 0x7693,
            0xe1aa: 0x7699,
            0xe1ab: 0x769a,
            0xe1ac: 0x76b0,
            0xe1ad: 0x76b4,
            0xe1ae: 0x76b8,
            0xe1af: 0x76b9,
            0xe1b0: 0x76ba,
            0xe1b1: 0x76c2,
            0xe1b2: 0x76cd,
            0xe1b3: 0x76d6,
            0xe1b4: 0x76d2,
            0xe1b5: 0x76de,
            0xe1b6: 0x76e1,
            0xe1b7: 0x76e5,
            0xe1b8: 0x76e7,
            0xe1b9: 0x76ea,
            0xe1ba: 0x862f,
            0xe1bb: 0x76fb,
            0xe1bc: 0x7708,
            0xe1bd: 0x7707,
            0xe1be: 0x7704,
            0xe1bf: 0x7729,
            0xe1c0: 0x7724,
            0xe1c1: 0x771e,
            0xe1c2: 0x7725,
            0xe1c3: 0x7726,
            0xe1c4: 0x771b,
            0xe1c5: 0x7737,
            0xe1c6: 0x7738,
            0xe1c7: 0x7747,
            0xe1c8: 0x775a,
            0xe1c9: 0x7768,
            0xe1ca: 0x776b,
            0xe1cb: 0x775b,
            0xe1cc: 0x7765,
            0xe1cd: 0x777f,
            0xe1ce: 0x777e,
            0xe1cf: 0x7779,
            0xe1d0: 0x778e,
            0xe1d1: 0x778b,
            0xe1d2: 0x7791,
            0xe1d3: 0x77a0,
            0xe1d4: 0x779e,
            0xe1d5: 0x77b0,
            0xe1d6: 0x77b6,
            0xe1d7: 0x77b9,
            0xe1d8: 0x77bf,
            0xe1d9: 0x77bc,
            0xe1da: 0x77bd,
            0xe1db: 0x77bb,
            0xe1dc: 0x77c7,
            0xe1dd: 0x77cd,
            0xe1de: 0x77d7,
            0xe1df: 0x77da,
            0xe1e0: 0x77dc,
            0xe1e1: 0x77e3,
            0xe1e2: 0x77ee,
            0xe1e3: 0x77fc,
            0xe1e4: 0x780c,
            0xe1e5: 0x7812,
            0xe1e6: 0x7926,
            0xe1e7: 0x7820,
            0xe1e8: 0x792a,
            0xe1e9: 0x7845,
            0xe1ea: 0x788e,
            0xe1eb: 0x7874,
            0xe1ec: 0x7886,
            0xe1ed: 0x787c,
            0xe1ee: 0x789a,
            0xe1ef: 0x788c,
            0xe1f0: 0x78a3,
            0xe1f1: 0x78b5,
            0xe1f2: 0x78aa,
            0xe1f3: 0x78af,
            0xe1f4: 0x78d1,
            0xe1f5: 0x78c6,
            0xe1f6: 0x78cb,
            0xe1f7: 0x78d4,
            0xe1f8: 0x78be,
            0xe1f9: 0x78bc,
            0xe1fa: 0x78c5,
            0xe1fb: 0x78ca,
            0xe1fc: 0x78ec,
            0xe240: 0x78e7,
            0xe241: 0x78da,
            0xe242: 0x78fd,
            0xe243: 0x78f4,
            0xe244: 0x7907,
            0xe245: 0x7912,
            0xe246: 0x7911,
            0xe247: 0x7919,
            0xe248: 0x792c,
            0xe249: 0x792b,
            0xe24a: 0x7940,
            0xe24b: 0x7960,
            0xe24c: 0x7957,
            0xe24d: 0x795f,
            0xe24e: 0x795a,
            0xe24f: 0x7955,
            0xe250: 0x7953,
            0xe251: 0x797a,
            0xe252: 0x797f,
            0xe253: 0x798a,
            0xe254: 0x799d,
            0xe255: 0x79a7,
            0xe256: 0x9f4b,
            0xe257: 0x79aa,
            0xe258: 0x79ae,
            0xe259: 0x79b3,
            0xe25a: 0x79b9,
            0xe25b: 0x79ba,
            0xe25c: 0x79c9,
            0xe25d: 0x79d5,
            0xe25e: 0x79e7,
            0xe25f: 0x79ec,
            0xe260: 0x79e1,
            0xe261: 0x79e3,
            0xe262: 0x7a08,
            0xe263: 0x7a0d,
            0xe264: 0x7a18,
            0xe265: 0x7a19,
            0xe266: 0x7a20,
            0xe267: 0x7a1f,
            0xe268: 0x7980,
            0xe269: 0x7a31,
            0xe26a: 0x7a3b,
            0xe26b: 0x7a3e,
            0xe26c: 0x7a37,
            0xe26d: 0x7a43,
            0xe26e: 0x7a57,
            0xe26f: 0x7a49,
            0xe270: 0x7a61,
            0xe271: 0x7a62,
            0xe272: 0x7a69,
            0xe273: 0x9f9d,
            0xe274: 0x7a70,
            0xe275: 0x7a79,
            0xe276: 0x7a7d,
            0xe277: 0x7a88,
            0xe278: 0x7a97,
            0xe279: 0x7a95,
            0xe27a: 0x7a98,
            0xe27b: 0x7a96,
            0xe27c: 0x7aa9,
            0xe27d: 0x7ac8,
            0xe27e: 0x7ab0,
            0xe280: 0x7ab6,
            0xe281: 0x7ac5,
            0xe282: 0x7ac4,
            0xe283: 0x7abf,
            0xe284: 0x9083,
            0xe285: 0x7ac7,
            0xe286: 0x7aca,
            0xe287: 0x7acd,
            0xe288: 0x7acf,
            0xe289: 0x7ad5,
            0xe28a: 0x7ad3,
            0xe28b: 0x7ad9,
            0xe28c: 0x7ada,
            0xe28d: 0x7add,
            0xe28e: 0x7ae1,
            0xe28f: 0x7ae2,
            0xe290: 0x7ae6,
            0xe291: 0x7aed,
            0xe292: 0x7af0,
            0xe293: 0x7b02,
            0xe294: 0x7b0f,
            0xe295: 0x7b0a,
            0xe296: 0x7b06,
            0xe297: 0x7b33,
            0xe298: 0x7b18,
            0xe299: 0x7b19,
            0xe29a: 0x7b1e,
            0xe29b: 0x7b35,
            0xe29c: 0x7b28,
            0xe29d: 0x7b36,
            0xe29e: 0x7b50,
            0xe29f: 0x7b7a,
            0xe2a0: 0x7b04,
            0xe2a1: 0x7b4d,
            0xe2a2: 0x7b0b,
            0xe2a3: 0x7b4c,
            0xe2a4: 0x7b45,
            0xe2a5: 0x7b75,
            0xe2a6: 0x7b65,
            0xe2a7: 0x7b74,
            0xe2a8: 0x7b67,
            0xe2a9: 0x7b70,
            0xe2aa: 0x7b71,
            0xe2ab: 0x7b6c,
            0xe2ac: 0x7b6e,
            0xe2ad: 0x7b9d,
            0xe2ae: 0x7b98,
            0xe2af: 0x7b9f,
            0xe2b0: 0x7b8d,
            0xe2b1: 0x7b9c,
            0xe2b2: 0x7b9a,
            0xe2b3: 0x7b8b,
            0xe2b4: 0x7b92,
            0xe2b5: 0x7b8f,
            0xe2b6: 0x7b5d,
            0xe2b7: 0x7b99,
            0xe2b8: 0x7bcb,
            0xe2b9: 0x7bc1,
            0xe2ba: 0x7bcc,
            0xe2bb: 0x7bcf,
            0xe2bc: 0x7bb4,
            0xe2bd: 0x7bc6,
            0xe2be: 0x7bdd,
            0xe2bf: 0x7be9,
            0xe2c0: 0x7c11,
            0xe2c1: 0x7c14,
            0xe2c2: 0x7be6,
            0xe2c3: 0x7be5,
            0xe2c4: 0x7c60,
            0xe2c5: 0x7c00,
            0xe2c6: 0x7c07,
            0xe2c7: 0x7c13,
            0xe2c8: 0x7bf3,
            0xe2c9: 0x7bf7,
            0xe2ca: 0x7c17,
            0xe2cb: 0x7c0d,
            0xe2cc: 0x7bf6,
            0xe2cd: 0x7c23,
            0xe2ce: 0x7c27,
            0xe2cf: 0x7c2a,
            0xe2d0: 0x7c1f,
            0xe2d1: 0x7c37,
            0xe2d2: 0x7c2b,
            0xe2d3: 0x7c3d,
            0xe2d4: 0x7c4c,
            0xe2d5: 0x7c43,
            0xe2d6: 0x7c54,
            0xe2d7: 0x7c4f,
            0xe2d8: 0x7c40,
            0xe2d9: 0x7c50,
            0xe2da: 0x7c58,
            0xe2db: 0x7c5f,
            0xe2dc: 0x7c64,
            0xe2dd: 0x7c56,
            0xe2de: 0x7c65,
            0xe2df: 0x7c6c,
            0xe2e0: 0x7c75,
            0xe2e1: 0x7c83,
            0xe2e2: 0x7c90,
            0xe2e3: 0x7ca4,
            0xe2e4: 0x7cad,
            0xe2e5: 0x7ca2,
            0xe2e6: 0x7cab,
            0xe2e7: 0x7ca1,
            0xe2e8: 0x7ca8,
            0xe2e9: 0x7cb3,
            0xe2ea: 0x7cb2,
            0xe2eb: 0x7cb1,
            0xe2ec: 0x7cae,
            0xe2ed: 0x7cb9,
            0xe2ee: 0x7cbd,
            0xe2ef: 0x7cc0,
            0xe2f0: 0x7cc5,
            0xe2f1: 0x7cc2,
            0xe2f2: 0x7cd8,
            0xe2f3: 0x7cd2,
            0xe2f4: 0x7cdc,
            0xe2f5: 0x7ce2,
            0xe2f6: 0x9b3b,
            0xe2f7: 0x7cef,
            0xe2f8: 0x7cf2,
            0xe2f9: 0x7cf4,
            0xe2fa: 0x7cf6,
            0xe2fb: 0x7cfa,
            0xe2fc: 0x7d06,
            0xe340: 0x7d02,
            0xe341: 0x7d1c,
            0xe342: 0x7d15,
            0xe343: 0x7d0a,
            0xe344: 0x7d45,
            0xe345: 0x7d4b,
            0xe346: 0x7d2e,
            0xe347: 0x7d32,
            0xe348: 0x7d3f,
            0xe349: 0x7d35,
            0xe34a: 0x7d46,
            0xe34b: 0x7d73,
            0xe34c: 0x7d56,
            0xe34d: 0x7d4e,
            0xe34e: 0x7d72,
            0xe34f: 0x7d68,
            0xe350: 0x7d6e,
            0xe351: 0x7d4f,
            0xe352: 0x7d63,
            0xe353: 0x7d93,
            0xe354: 0x7d89,
            0xe355: 0x7d5b,
            0xe356: 0x7d8f,
            0xe357: 0x7d7d,
            0xe358: 0x7d9b,
            0xe359: 0x7dba,
            0xe35a: 0x7dae,
            0xe35b: 0x7da3,
            0xe35c: 0x7db5,
            0xe35d: 0x7dc7,
            0xe35e: 0x7dbd,
            0xe35f: 0x7dab,
            0xe360: 0x7e3d,
            0xe361: 0x7da2,
            0xe362: 0x7daf,
            0xe363: 0x7ddc,
            0xe364: 0x7db8,
            0xe365: 0x7d9f,
            0xe366: 0x7db0,
            0xe367: 0x7dd8,
            0xe368: 0x7ddd,
            0xe369: 0x7de4,
            0xe36a: 0x7dde,
            0xe36b: 0x7dfb,
            0xe36c: 0x7df2,
            0xe36d: 0x7de1,
            0xe36e: 0x7e05,
            0xe36f: 0x7e0a,
            0xe370: 0x7e23,
            0xe371: 0x7e21,
            0xe372: 0x7e12,
            0xe373: 0x7e31,
            0xe374: 0x7e1f,
            0xe375: 0x7e09,
            0xe376: 0x7e0b,
            0xe377: 0x7e22,
            0xe378: 0x7e46,
            0xe379: 0x7e66,
            0xe37a: 0x7e3b,
            0xe37b: 0x7e35,
            0xe37c: 0x7e39,
            0xe37d: 0x7e43,
            0xe37e: 0x7e37,
            0xe380: 0x7e32,
            0xe381: 0x7e3a,
            0xe382: 0x7e67,
            0xe383: 0x7e5d,
            0xe384: 0x7e56,
            0xe385: 0x7e5e,
            0xe386: 0x7e59,
            0xe387: 0x7e5a,
            0xe388: 0x7e79,
            0xe389: 0x7e6a,
            0xe38a: 0x7e69,
            0xe38b: 0x7e7c,
            0xe38c: 0x7e7b,
            0xe38d: 0x7e83,
            0xe38e: 0x7dd5,
            0xe38f: 0x7e7d,
            0xe390: 0x8fae,
            0xe391: 0x7e7f,
            0xe392: 0x7e88,
            0xe393: 0x7e89,
            0xe394: 0x7e8c,
            0xe395: 0x7e92,
            0xe396: 0x7e90,
            0xe397: 0x7e93,
            0xe398: 0x7e94,
            0xe399: 0x7e96,
            0xe39a: 0x7e8e,
            0xe39b: 0x7e9b,
            0xe39c: 0x7e9c,
            0xe39d: 0x7f38,
            0xe39e: 0x7f3a,
            0xe39f: 0x7f45,
            0xe3a0: 0x7f4c,
            0xe3a1: 0x7f4d,
            0xe3a2: 0x7f4e,
            0xe3a3: 0x7f50,
            0xe3a4: 0x7f51,
            0xe3a5: 0x7f55,
            0xe3a6: 0x7f54,
            0xe3a7: 0x7f58,
            0xe3a8: 0x7f5f,
            0xe3a9: 0x7f60,
            0xe3aa: 0x7f68,
            0xe3ab: 0x7f69,
            0xe3ac: 0x7f67,
            0xe3ad: 0x7f78,
            0xe3ae: 0x7f82,
            0xe3af: 0x7f86,
            0xe3b0: 0x7f83,
            0xe3b1: 0x7f88,
            0xe3b2: 0x7f87,
            0xe3b3: 0x7f8c,
            0xe3b4: 0x7f94,
            0xe3b5: 0x7f9e,
            0xe3b6: 0x7f9d,
            0xe3b7: 0x7f9a,
            0xe3b8: 0x7fa3,
            0xe3b9: 0x7faf,
            0xe3ba: 0x7fb2,
            0xe3bb: 0x7fb9,
            0xe3bc: 0x7fae,
            0xe3bd: 0x7fb6,
            0xe3be: 0x7fb8,
            0xe3bf: 0x8b71,
            0xe3c0: 0x7fc5,
            0xe3c1: 0x7fc6,
            0xe3c2: 0x7fca,
            0xe3c3: 0x7fd5,
            0xe3c4: 0x7fd4,
            0xe3c5: 0x7fe1,
            0xe3c6: 0x7fe6,
            0xe3c7: 0x7fe9,
            0xe3c8: 0x7ff3,
            0xe3c9: 0x7ff9,
            0xe3ca: 0x98dc,
            0xe3cb: 0x8006,
            0xe3cc: 0x8004,
            0xe3cd: 0x800b,
            0xe3ce: 0x8012,
            0xe3cf: 0x8018,
            0xe3d0: 0x8019,
            0xe3d1: 0x801c,
            0xe3d2: 0x8021,
            0xe3d3: 0x8028,
            0xe3d4: 0x803f,
            0xe3d5: 0x803b,
            0xe3d6: 0x804a,
            0xe3d7: 0x8046,
            0xe3d8: 0x8052,
            0xe3d9: 0x8058,
            0xe3da: 0x805a,
            0xe3db: 0x805f,
            0xe3dc: 0x8062,
            0xe3dd: 0x8068,
            0xe3de: 0x8073,
            0xe3df: 0x8072,
            0xe3e0: 0x8070,
            0xe3e1: 0x8076,
            0xe3e2: 0x8079,
            0xe3e3: 0x807d,
            0xe3e4: 0x807f,
            0xe3e5: 0x8084,
            0xe3e6: 0x8086,
            0xe3e7: 0x8085,
            0xe3e8: 0x809b,
            0xe3e9: 0x8093,
            0xe3ea: 0x809a,
            0xe3eb: 0x80ad,
            0xe3ec: 0x5190,
            0xe3ed: 0x80ac,
            0xe3ee: 0x80db,
            0xe3ef: 0x80e5,
            0xe3f0: 0x80d9,
            0xe3f1: 0x80dd,
            0xe3f2: 0x80c4,
            0xe3f3: 0x80da,
            0xe3f4: 0x80d6,
            0xe3f5: 0x8109,
            0xe3f6: 0x80ef,
            0xe3f7: 0x80f1,
            0xe3f8: 0x811b,
            0xe3f9: 0x8129,
            0xe3fa: 0x8123,
            0xe3fb: 0x812f,
            0xe3fc: 0x814b,
            0xe440: 0x968b,
            0xe441: 0x8146,
            0xe442: 0x813e,
            0xe443: 0x8153,
            0xe444: 0x8151,
            0xe445: 0x80fc,
            0xe446: 0x8171,
            0xe447: 0x816e,
            0xe448: 0x8165,
            0xe449: 0x8166,
            0xe44a: 0x8174,
            0xe44b: 0x8183,
            0xe44c: 0x8188,
            0xe44d: 0x818a,
            0xe44e: 0x8180,
            0xe44f: 0x8182,
            0xe450: 0x81a0,
            0xe451: 0x8195,
            0xe452: 0x81a4,
            0xe453: 0x81a3,
            0xe454: 0x815f,
            0xe455: 0x8193,
            0xe456: 0x81a9,
            0xe457: 0x81b0,
            0xe458: 0x81b5,
            0xe459: 0x81be,
            0xe45a: 0x81b8,
            0xe45b: 0x81bd,
            0xe45c: 0x81c0,
            0xe45d: 0x81c2,
            0xe45e: 0x81ba,
            0xe45f: 0x81c9,
            0xe460: 0x81cd,
            0xe461: 0x81d1,
            0xe462: 0x81d9,
            0xe463: 0x81d8,
            0xe464: 0x81c8,
            0xe465: 0x81da,
            0xe466: 0x81df,
            0xe467: 0x81e0,
            0xe468: 0x81e7,
            0xe469: 0x81fa,
            0xe46a: 0x81fb,
            0xe46b: 0x81fe,
            0xe46c: 0x8201,
            0xe46d: 0x8202,
            0xe46e: 0x8205,
            0xe46f: 0x8207,
            0xe470: 0x820a,
            0xe471: 0x820d,
            0xe472: 0x8210,
            0xe473: 0x8216,
            0xe474: 0x8229,
            0xe475: 0x822b,
            0xe476: 0x8238,
            0xe477: 0x8233,
            0xe478: 0x8240,
            0xe479: 0x8259,
            0xe47a: 0x8258,
            0xe47b: 0x825d,
            0xe47c: 0x825a,
            0xe47d: 0x825f,
            0xe47e: 0x8264,
            0xe480: 0x8262,
            0xe481: 0x8268,
            0xe482: 0x826a,
            0xe483: 0x826b,
            0xe484: 0x822e,
            0xe485: 0x8271,
            0xe486: 0x8277,
            0xe487: 0x8278,
            0xe488: 0x827e,
            0xe489: 0x828d,
            0xe48a: 0x8292,
            0xe48b: 0x82ab,
            0xe48c: 0x829f,
            0xe48d: 0x82bb,
            0xe48e: 0x82ac,
            0xe48f: 0x82e1,
            0xe490: 0x82e3,
            0xe491: 0x82df,
            0xe492: 0x82d2,
            0xe493: 0x82f4,
            0xe494: 0x82f3,
            0xe495: 0x82fa,
            0xe496: 0x8393,
            0xe497: 0x8303,
            0xe498: 0x82fb,
            0xe499: 0x82f9,
            0xe49a: 0x82de,
            0xe49b: 0x8306,
            0xe49c: 0x82dc,
            0xe49d: 0x8309,
            0xe49e: 0x82d9,
            0xe49f: 0x8335,
            0xe4a0: 0x8334,
            0xe4a1: 0x8316,
            0xe4a2: 0x8332,
            0xe4a3: 0x8331,
            0xe4a4: 0x8340,
            0xe4a5: 0x8339,
            0xe4a6: 0x8350,
            0xe4a7: 0x8345,
            0xe4a8: 0x832f,
            0xe4a9: 0x832b,
            0xe4aa: 0x8317,
            0xe4ab: 0x8318,
            0xe4ac: 0x8385,
            0xe4ad: 0x839a,
            0xe4ae: 0x83aa,
            0xe4af: 0x839f,
            0xe4b0: 0x83a2,
            0xe4b1: 0x8396,
            0xe4b2: 0x8323,
            0xe4b3: 0x838e,
            0xe4b4: 0x8387,
            0xe4b5: 0x838a,
            0xe4b6: 0x837c,
            0xe4b7: 0x83b5,
            0xe4b8: 0x8373,
            0xe4b9: 0x8375,
            0xe4ba: 0x83a0,
            0xe4bb: 0x8389,
            0xe4bc: 0x83a8,
            0xe4bd: 0x83f4,
            0xe4be: 0x8413,
            0xe4bf: 0x83eb,
            0xe4c0: 0x83ce,
            0xe4c1: 0x83fd,
            0xe4c2: 0x8403,
            0xe4c3: 0x83d8,
            0xe4c4: 0x840b,
            0xe4c5: 0x83c1,
            0xe4c6: 0x83f7,
            0xe4c7: 0x8407,
            0xe4c8: 0x83e0,
            0xe4c9: 0x83f2,
            0xe4ca: 0x840d,
            0xe4cb: 0x8422,
            0xe4cc: 0x8420,
            0xe4cd: 0x83bd,
            0xe4ce: 0x8438,
            0xe4cf: 0x8506,
            0xe4d0: 0x83fb,
            0xe4d1: 0x846d,
            0xe4d2: 0x842a,
            0xe4d3: 0x843c,
            0xe4d4: 0x855a,
            0xe4d5: 0x8484,
            0xe4d6: 0x8477,
            0xe4d7: 0x846b,
            0xe4d8: 0x84ad,
            0xe4d9: 0x846e,
            0xe4da: 0x8482,
            0xe4db: 0x8469,
            0xe4dc: 0x8446,
            0xe4dd: 0x842c,
            0xe4de: 0x846f,
            0xe4df: 0x8479,
            0xe4e0: 0x8435,
            0xe4e1: 0x84ca,
            0xe4e2: 0x8462,
            0xe4e3: 0x84b9,
            0xe4e4: 0x84bf,
            0xe4e5: 0x849f,
            0xe4e6: 0x84d9,
            0xe4e7: 0x84cd,
            0xe4e8: 0x84bb,
            0xe4e9: 0x84da,
            0xe4ea: 0x84d0,
            0xe4eb: 0x84c1,
            0xe4ec: 0x84c6,
            0xe4ed: 0x84d6,
            0xe4ee: 0x84a1,
            0xe4ef: 0x8521,
            0xe4f0: 0x84ff,
            0xe4f1: 0x84f4,
            0xe4f2: 0x8517,
            0xe4f3: 0x8518,
            0xe4f4: 0x852c,
            0xe4f5: 0x851f,
            0xe4f6: 0x8515,
            0xe4f7: 0x8514,
            0xe4f8: 0x84fc,
            0xe4f9: 0x8540,
            0xe4fa: 0x8563,
            0xe4fb: 0x8558,
            0xe4fc: 0x8548,
            0xe540: 0x8541,
            0xe541: 0x8602,
            0xe542: 0x854b,
            0xe543: 0x8555,
            0xe544: 0x8580,
            0xe545: 0x85a4,
            0xe546: 0x8588,
            0xe547: 0x8591,
            0xe548: 0x858a,
            0xe549: 0x85a8,
            0xe54a: 0x856d,
            0xe54b: 0x8594,
            0xe54c: 0x859b,
            0xe54d: 0x85ea,
            0xe54e: 0x8587,
            0xe54f: 0x859c,
            0xe550: 0x8577,
            0xe551: 0x857e,
            0xe552: 0x8590,
            0xe553: 0x85c9,
            0xe554: 0x85ba,
            0xe555: 0x85cf,
            0xe556: 0x85b9,
            0xe557: 0x85d0,
            0xe558: 0x85d5,
            0xe559: 0x85dd,
            0xe55a: 0x85e5,
            0xe55b: 0x85dc,
            0xe55c: 0x85f9,
            0xe55d: 0x860a,
            0xe55e: 0x8613,
            0xe55f: 0x860b,
            0xe560: 0x85fe,
            0xe561: 0x85fa,
            0xe562: 0x8606,
            0xe563: 0x8622,
            0xe564: 0x861a,
            0xe565: 0x8630,
            0xe566: 0x863f,
            0xe567: 0x864d,
            0xe568: 0x4e55,
            0xe569: 0x8654,
            0xe56a: 0x865f,
            0xe56b: 0x8667,
            0xe56c: 0x8671,
            0xe56d: 0x8693,
            0xe56e: 0x86a3,
            0xe56f: 0x86a9,
            0xe570: 0x86aa,
            0xe571: 0x868b,
            0xe572: 0x868c,
            0xe573: 0x86b6,
            0xe574: 0x86af,
            0xe575: 0x86c4,
            0xe576: 0x86c6,
            0xe577: 0x86b0,
            0xe578: 0x86c9,
            0xe579: 0x8823,
            0xe57a: 0x86ab,
            0xe57b: 0x86d4,
            0xe57c: 0x86de,
            0xe57d: 0x86e9,
            0xe57e: 0x86ec,
            0xe580: 0x86df,
            0xe581: 0x86db,
            0xe582: 0x86ef,
            0xe583: 0x8712,
            0xe584: 0x8706,
            0xe585: 0x8708,
            0xe586: 0x8700,
            0xe587: 0x8703,
            0xe588: 0x86fb,
            0xe589: 0x8711,
            0xe58a: 0x8709,
            0xe58b: 0x870d,
            0xe58c: 0x86f9,
            0xe58d: 0x870a,
            0xe58e: 0x8734,
            0xe58f: 0x873f,
            0xe590: 0x8737,
            0xe591: 0x873b,
            0xe592: 0x8725,
            0xe593: 0x8729,
            0xe594: 0x871a,
            0xe595: 0x8760,
            0xe596: 0x875f,
            0xe597: 0x8778,
            0xe598: 0x874c,
            0xe599: 0x874e,
            0xe59a: 0x8774,
            0xe59b: 0x8757,
            0xe59c: 0x8768,
            0xe59d: 0x876e,
            0xe59e: 0x8759,
            0xe59f: 0x8753,
            0xe5a0: 0x8763,
            0xe5a1: 0x876a,
            0xe5a2: 0x8805,
            0xe5a3: 0x87a2,
            0xe5a4: 0x879f,
            0xe5a5: 0x8782,
            0xe5a6: 0x87af,
            0xe5a7: 0x87cb,
            0xe5a8: 0x87bd,
            0xe5a9: 0x87c0,
            0xe5aa: 0x87d0,
            0xe5ab: 0x96d6,
            0xe5ac: 0x87ab,
            0xe5ad: 0x87c4,
            0xe5ae: 0x87b3,
            0xe5af: 0x87c7,
            0xe5b0: 0x87c6,
            0xe5b1: 0x87bb,
            0xe5b2: 0x87ef,
            0xe5b3: 0x87f2,
            0xe5b4: 0x87e0,
            0xe5b5: 0x880f,
            0xe5b6: 0x880d,
            0xe5b7: 0x87fe,
            0xe5b8: 0x87f6,
            0xe5b9: 0x87f7,
            0xe5ba: 0x880e,
            0xe5bb: 0x87d2,
            0xe5bc: 0x8811,
            0xe5bd: 0x8816,
            0xe5be: 0x8815,
            0xe5bf: 0x8822,
            0xe5c0: 0x8821,
            0xe5c1: 0x8831,
            0xe5c2: 0x8836,
            0xe5c3: 0x8839,
            0xe5c4: 0x8827,
            0xe5c5: 0x883b,
            0xe5c6: 0x8844,
            0xe5c7: 0x8842,
            0xe5c8: 0x8852,
            0xe5c9: 0x8859,
            0xe5ca: 0x885e,
            0xe5cb: 0x8862,
            0xe5cc: 0x886b,
            0xe5cd: 0x8881,
            0xe5ce: 0x887e,
            0xe5cf: 0x889e,
            0xe5d0: 0x8875,
            0xe5d1: 0x887d,
            0xe5d2: 0x88b5,
            0xe5d3: 0x8872,
            0xe5d4: 0x8882,
            0xe5d5: 0x8897,
            0xe5d6: 0x8892,
            0xe5d7: 0x88ae,
            0xe5d8: 0x8899,
            0xe5d9: 0x88a2,
            0xe5da: 0x888d,
            0xe5db: 0x88a4,
            0xe5dc: 0x88b0,
            0xe5dd: 0x88bf,
            0xe5de: 0x88b1,
            0xe5df: 0x88c3,
            0xe5e0: 0x88c4,
            0xe5e1: 0x88d4,
            0xe5e2: 0x88d8,
            0xe5e3: 0x88d9,
            0xe5e4: 0x88dd,
            0xe5e5: 0x88f9,
            0xe5e6: 0x8902,
            0xe5e7: 0x88fc,
            0xe5e8: 0x88f4,
            0xe5e9: 0x88e8,
            0xe5ea: 0x88f2,
            0xe5eb: 0x8904,
            0xe5ec: 0x890c,
            0xe5ed: 0x890a,
            0xe5ee: 0x8913,
            0xe5ef: 0x8943,
            0xe5f0: 0x891e,
            0xe5f1: 0x8925,
            0xe5f2: 0x892a,
            0xe5f3: 0x892b,
            0xe5f4: 0x8941,
            0xe5f5: 0x8944,
            0xe5f6: 0x893b,
            0xe5f7: 0x8936,
            0xe5f8: 0x8938,
            0xe5f9: 0x894c,
            0xe5fa: 0x891d,
            0xe5fb: 0x8960,
            0xe5fc: 0x895e,
            0xe640: 0x8966,
            0xe641: 0x8964,
            0xe642: 0x896d,
            0xe643: 0x896a,
            0xe644: 0x896f,
            0xe645: 0x8974,
            0xe646: 0x8977,
            0xe647: 0x897e,
            0xe648: 0x8983,
            0xe649: 0x8988,
            0xe64a: 0x898a,
            0xe64b: 0x8993,
            0xe64c: 0x8998,
            0xe64d: 0x89a1,
            0xe64e: 0x89a9,
            0xe64f: 0x89a6,
            0xe650: 0x89ac,
            0xe651: 0x89af,
            0xe652: 0x89b2,
            0xe653: 0x89ba,
            0xe654: 0x89bd,
            0xe655: 0x89bf,
            0xe656: 0x89c0,
            0xe657: 0x89da,
            0xe658: 0x89dc,
            0xe659: 0x89dd,
            0xe65a: 0x89e7,
            0xe65b: 0x89f4,
            0xe65c: 0x89f8,
            0xe65d: 0x8a03,
            0xe65e: 0x8a16,
            0xe65f: 0x8a10,
            0xe660: 0x8a0c,
            0xe661: 0x8a1b,
            0xe662: 0x8a1d,
            0xe663: 0x8a25,
            0xe664: 0x8a36,
            0xe665: 0x8a41,
            0xe666: 0x8a5b,
            0xe667: 0x8a52,
            0xe668: 0x8a46,
            0xe669: 0x8a48,
            0xe66a: 0x8a7c,
            0xe66b: 0x8a6d,
            0xe66c: 0x8a6c,
            0xe66d: 0x8a62,
            0xe66e: 0x8a85,
            0xe66f: 0x8a82,
            0xe670: 0x8a84,
            0xe671: 0x8aa8,
            0xe672: 0x8aa1,
            0xe673: 0x8a91,
            0xe674: 0x8aa5,
            0xe675: 0x8aa6,
            0xe676: 0x8a9a,
            0xe677: 0x8aa3,
            0xe678: 0x8ac4,
            0xe679: 0x8acd,
            0xe67a: 0x8ac2,
            0xe67b: 0x8ada,
            0xe67c: 0x8aeb,
            0xe67d: 0x8af3,
            0xe67e: 0x8ae7,
            0xe680: 0x8ae4,
            0xe681: 0x8af1,
            0xe682: 0x8b14,
            0xe683: 0x8ae0,
            0xe684: 0x8ae2,
            0xe685: 0x8af7,
            0xe686: 0x8ade,
            0xe687: 0x8adb,
            0xe688: 0x8b0c,
            0xe689: 0x8b07,
            0xe68a: 0x8b1a,
            0xe68b: 0x8ae1,
            0xe68c: 0x8b16,
            0xe68d: 0x8b10,
            0xe68e: 0x8b17,
            0xe68f: 0x8b20,
            0xe690: 0x8b33,
            0xe691: 0x97ab,
            0xe692: 0x8b26,
            0xe693: 0x8b2b,
            0xe694: 0x8b3e,
            0xe695: 0x8b28,
            0xe696: 0x8b41,
            0xe697: 0x8b4c,
            0xe698: 0x8b4f,
            0xe699: 0x8b4e,
            0xe69a: 0x8b49,
            0xe69b: 0x8b56,
            0xe69c: 0x8b5b,
            0xe69d: 0x8b5a,
            0xe69e: 0x8b6b,
            0xe69f: 0x8b5f,
            0xe6a0: 0x8b6c,
            0xe6a1: 0x8b6f,
            0xe6a2: 0x8b74,
            0xe6a3: 0x8b7d,
            0xe6a4: 0x8b80,
            0xe6a5: 0x8b8c,
            0xe6a6: 0x8b8e,
            0xe6a7: 0x8b92,
            0xe6a8: 0x8b93,
            0xe6a9: 0x8b96,
            0xe6aa: 0x8b99,
            0xe6ab: 0x8b9a,
            0xe6ac: 0x8c3a,
            0xe6ad: 0x8c41,
            0xe6ae: 0x8c3f,
            0xe6af: 0x8c48,
            0xe6b0: 0x8c4c,
            0xe6b1: 0x8c4e,
            0xe6b2: 0x8c50,
            0xe6b3: 0x8c55,
            0xe6b4: 0x8c62,
            0xe6b5: 0x8c6c,
            0xe6b6: 0x8c78,
            0xe6b7: 0x8c7a,
            0xe6b8: 0x8c82,
            0xe6b9: 0x8c89,
            0xe6ba: 0x8c85,
            0xe6bb: 0x8c8a,
            0xe6bc: 0x8c8d,
            0xe6bd: 0x8c8e,
            0xe6be: 0x8c94,
            0xe6bf: 0x8c7c,
            0xe6c0: 0x8c98,
            0xe6c1: 0x621d,
            0xe6c2: 0x8cad,
            0xe6c3: 0x8caa,
            0xe6c4: 0x8cbd,
            0xe6c5: 0x8cb2,
            0xe6c6: 0x8cb3,
            0xe6c7: 0x8cae,
            0xe6c8: 0x8cb6,
            0xe6c9: 0x8cc8,
            0xe6ca: 0x8cc1,
            0xe6cb: 0x8ce4,
            0xe6cc: 0x8ce3,
            0xe6cd: 0x8cda,
            0xe6ce: 0x8cfd,
            0xe6cf: 0x8cfa,
            0xe6d0: 0x8cfb,
            0xe6d1: 0x8d04,
            0xe6d2: 0x8d05,
            0xe6d3: 0x8d0a,
            0xe6d4: 0x8d07,
            0xe6d5: 0x8d0f,
            0xe6d6: 0x8d0d,
            0xe6d7: 0x8d10,
            0xe6d8: 0x9f4e,
            0xe6d9: 0x8d13,
            0xe6da: 0x8ccd,
            0xe6db: 0x8d14,
            0xe6dc: 0x8d16,
            0xe6dd: 0x8d67,
            0xe6de: 0x8d6d,
            0xe6df: 0x8d71,
            0xe6e0: 0x8d73,
            0xe6e1: 0x8d81,
            0xe6e2: 0x8d99,
            0xe6e3: 0x8dc2,
            0xe6e4: 0x8dbe,
            0xe6e5: 0x8dba,
            0xe6e6: 0x8dcf,
            0xe6e7: 0x8dda,
            0xe6e8: 0x8dd6,
            0xe6e9: 0x8dcc,
            0xe6ea: 0x8ddb,
            0xe6eb: 0x8dcb,
            0xe6ec: 0x8dea,
            0xe6ed: 0x8deb,
            0xe6ee: 0x8ddf,
            0xe6ef: 0x8de3,
            0xe6f0: 0x8dfc,
            0xe6f1: 0x8e08,
            0xe6f2: 0x8e09,
            0xe6f3: 0x8dff,
            0xe6f4: 0x8e1d,
            0xe6f5: 0x8e1e,
            0xe6f6: 0x8e10,
            0xe6f7: 0x8e1f,
            0xe6f8: 0x8e42,
            0xe6f9: 0x8e35,
            0xe6fa: 0x8e30,
            0xe6fb: 0x8e34,
            0xe6fc: 0x8e4a,
            0xe740: 0x8e47,
            0xe741: 0x8e49,
            0xe742: 0x8e4c,
            0xe743: 0x8e50,
            0xe744: 0x8e48,
            0xe745: 0x8e59,
            0xe746: 0x8e64,
            0xe747: 0x8e60,
            0xe748: 0x8e2a,
            0xe749: 0x8e63,
            0xe74a: 0x8e55,
            0xe74b: 0x8e76,
            0xe74c: 0x8e72,
            0xe74d: 0x8e7c,
            0xe74e: 0x8e81,
            0xe74f: 0x8e87,
            0xe750: 0x8e85,
            0xe751: 0x8e84,
            0xe752: 0x8e8b,
            0xe753: 0x8e8a,
            0xe754: 0x8e93,
            0xe755: 0x8e91,
            0xe756: 0x8e94,
            0xe757: 0x8e99,
            0xe758: 0x8eaa,
            0xe759: 0x8ea1,
            0xe75a: 0x8eac,
            0xe75b: 0x8eb0,
            0xe75c: 0x8ec6,
            0xe75d: 0x8eb1,
            0xe75e: 0x8ebe,
            0xe75f: 0x8ec5,
            0xe760: 0x8ec8,
            0xe761: 0x8ecb,
            0xe762: 0x8edb,
            0xe763: 0x8ee3,
            0xe764: 0x8efc,
            0xe765: 0x8efb,
            0xe766: 0x8eeb,
            0xe767: 0x8efe,
            0xe768: 0x8f0a,
            0xe769: 0x8f05,
            0xe76a: 0x8f15,
            0xe76b: 0x8f12,
            0xe76c: 0x8f19,
            0xe76d: 0x8f13,
            0xe76e: 0x8f1c,
            0xe76f: 0x8f1f,
            0xe770: 0x8f1b,
            0xe771: 0x8f0c,
            0xe772: 0x8f26,
            0xe773: 0x8f33,
            0xe774: 0x8f3b,
            0xe775: 0x8f39,
            0xe776: 0x8f45,
            0xe777: 0x8f42,
            0xe778: 0x8f3e,
            0xe779: 0x8f4c,
            0xe77a: 0x8f49,
            0xe77b: 0x8f46,
            0xe77c: 0x8f4e,
            0xe77d: 0x8f57,
            0xe77e: 0x8f5c,
            0xe780: 0x8f62,
            0xe781: 0x8f63,
            0xe782: 0x8f64,
            0xe783: 0x8f9c,
            0xe784: 0x8f9f,
            0xe785: 0x8fa3,
            0xe786: 0x8fad,
            0xe787: 0x8faf,
            0xe788: 0x8fb7,
            0xe789: 0x8fda,
            0xe78a: 0x8fe5,
            0xe78b: 0x8fe2,
            0xe78c: 0x8fea,
            0xe78d: 0x8fef,
            0xe78e: 0x9087,
            0xe78f: 0x8ff4,
            0xe790: 0x9005,
            0xe791: 0x8ff9,
            0xe792: 0x8ffa,
            0xe793: 0x9011,
            0xe794: 0x9015,
            0xe795: 0x9021,
            0xe796: 0x900d,
            0xe797: 0x901e,
            0xe798: 0x9016,
            0xe799: 0x900b,
            0xe79a: 0x9027,
            0xe79b: 0x9036,
            0xe79c: 0x9035,
            0xe79d: 0x9039,
            0xe79e: 0x8ff8,
            0xe79f: 0x904f,
            0xe7a0: 0x9050,
            0xe7a1: 0x9051,
            0xe7a2: 0x9052,
            0xe7a3: 0x900e,
            0xe7a4: 0x9049,
            0xe7a5: 0x903e,
            0xe7a6: 0x9056,
            0xe7a7: 0x9058,
            0xe7a8: 0x905e,
            0xe7a9: 0x9068,
            0xe7aa: 0x906f,
            0xe7ab: 0x9076,
            0xe7ac: 0x96a8,
            0xe7ad: 0x9072,
            0xe7ae: 0x9082,
            0xe7af: 0x907d,
            0xe7b0: 0x9081,
            0xe7b1: 0x9080,
            0xe7b2: 0x908a,
            0xe7b3: 0x9089,
            0xe7b4: 0x908f,
            0xe7b5: 0x90a8,
            0xe7b6: 0x90af,
            0xe7b7: 0x90b1,
            0xe7b8: 0x90b5,
            0xe7b9: 0x90e2,
            0xe7ba: 0x90e4,
            0xe7bb: 0x6248,
            0xe7bc: 0x90db,
            0xe7bd: 0x9102,
            0xe7be: 0x9112,
            0xe7bf: 0x9119,
            0xe7c0: 0x9132,
            0xe7c1: 0x9130,
            0xe7c2: 0x914a,
            0xe7c3: 0x9156,
            0xe7c4: 0x9158,
            0xe7c5: 0x9163,
            0xe7c6: 0x9165,
            0xe7c7: 0x9169,
            0xe7c8: 0x9173,
            0xe7c9: 0x9172,
            0xe7ca: 0x918b,
            0xe7cb: 0x9189,
            0xe7cc: 0x9182,
            0xe7cd: 0x91a2,
            0xe7ce: 0x91ab,
            0xe7cf: 0x91af,
            0xe7d0: 0x91aa,
            0xe7d1: 0x91b5,
            0xe7d2: 0x91b4,
            0xe7d3: 0x91ba,
            0xe7d4: 0x91c0,
            0xe7d5: 0x91c1,
            0xe7d6: 0x91c9,
            0xe7d7: 0x91cb,
            0xe7d8: 0x91d0,
            0xe7d9: 0x91d6,
            0xe7da: 0x91df,
            0xe7db: 0x91e1,
            0xe7dc: 0x91db,
            0xe7dd: 0x91fc,
            0xe7de: 0x91f5,
            0xe7df: 0x91f6,
            0xe7e0: 0x921e,
            0xe7e1: 0x91ff,
            0xe7e2: 0x9214,
            0xe7e3: 0x922c,
            0xe7e4: 0x9215,
            0xe7e5: 0x9211,
            0xe7e6: 0x925e,
            0xe7e7: 0x9257,
            0xe7e8: 0x9245,
            0xe7e9: 0x9249,
            0xe7ea: 0x9264,
            0xe7eb: 0x9248,
            0xe7ec: 0x9295,
            0xe7ed: 0x923f,
            0xe7ee: 0x924b,
            0xe7ef: 0x9250,
            0xe7f0: 0x929c,
            0xe7f1: 0x9296,
            0xe7f2: 0x9293,
            0xe7f3: 0x929b,
            0xe7f4: 0x925a,
            0xe7f5: 0x92cf,
            0xe7f6: 0x92b9,
            0xe7f7: 0x92b7,
            0xe7f8: 0x92e9,
            0xe7f9: 0x930f,
            0xe7fa: 0x92fa,
            0xe7fb: 0x9344,
            0xe7fc: 0x932e,
            0xe840: 0x9319,
            0xe841: 0x9322,
            0xe842: 0x931a,
            0xe843: 0x9323,
            0xe844: 0x933a,
            0xe845: 0x9335,
            0xe846: 0x933b,
            0xe847: 0x935c,
            0xe848: 0x9360,
            0xe849: 0x937c,
            0xe84a: 0x936e,
            0xe84b: 0x9356,
            0xe84c: 0x93b0,
            0xe84d: 0x93ac,
            0xe84e: 0x93ad,
            0xe84f: 0x9394,
            0xe850: 0x93b9,
            0xe851: 0x93d6,
            0xe852: 0x93d7,
            0xe853: 0x93e8,
            0xe854: 0x93e5,
            0xe855: 0x93d8,
            0xe856: 0x93c3,
            0xe857: 0x93dd,
            0xe858: 0x93d0,
            0xe859: 0x93c8,
            0xe85a: 0x93e4,
            0xe85b: 0x941a,
            0xe85c: 0x9414,
            0xe85d: 0x9413,
            0xe85e: 0x9403,
            0xe85f: 0x9407,
            0xe860: 0x9410,
            0xe861: 0x9436,
            0xe862: 0x942b,
            0xe863: 0x9435,
            0xe864: 0x9421,
            0xe865: 0x943a,
            0xe866: 0x9441,
            0xe867: 0x9452,
            0xe868: 0x9444,
            0xe869: 0x945b,
            0xe86a: 0x9460,
            0xe86b: 0x9462,
            0xe86c: 0x945e,
            0xe86d: 0x946a,
            0xe86e: 0x9229,
            0xe86f: 0x9470,
            0xe870: 0x9475,
            0xe871: 0x9477,
            0xe872: 0x947d,
            0xe873: 0x945a,
            0xe874: 0x947c,
            0xe875: 0x947e,
            0xe876: 0x9481,
            0xe877: 0x947f,
            0xe878: 0x9582,
            0xe879: 0x9587,
            0xe87a: 0x958a,
            0xe87b: 0x9594,
            0xe87c: 0x9596,
            0xe87d: 0x9598,
            0xe87e: 0x9599,
            0xe880: 0x95a0,
            0xe881: 0x95a8,
            0xe882: 0x95a7,
            0xe883: 0x95ad,
            0xe884: 0x95bc,
            0xe885: 0x95bb,
            0xe886: 0x95b9,
            0xe887: 0x95be,
            0xe888: 0x95ca,
            0xe889: 0x6ff6,
            0xe88a: 0x95c3,
            0xe88b: 0x95cd,
            0xe88c: 0x95cc,
            0xe88d: 0x95d5,
            0xe88e: 0x95d4,
            0xe88f: 0x95d6,
            0xe890: 0x95dc,
            0xe891: 0x95e1,
            0xe892: 0x95e5,
            0xe893: 0x95e2,
            0xe894: 0x9621,
            0xe895: 0x9628,
            0xe896: 0x962e,
            0xe897: 0x962f,
            0xe898: 0x9642,
            0xe899: 0x964c,
            0xe89a: 0x964f,
            0xe89b: 0x964b,
            0xe89c: 0x9677,
            0xe89d: 0x965c,
            0xe89e: 0x965e,
            0xe89f: 0x965d,
            0xe8a0: 0x965f,
            0xe8a1: 0x9666,
            0xe8a2: 0x9672,
            0xe8a3: 0x966c,
            0xe8a4: 0x968d,
            0xe8a5: 0x9698,
            0xe8a6: 0x9695,
            0xe8a7: 0x9697,
            0xe8a8: 0x96aa,
            0xe8a9: 0x96a7,
            0xe8aa: 0x96b1,
            0xe8ab: 0x96b2,
            0xe8ac: 0x96b0,
            0xe8ad: 0x96b4,
            0xe8ae: 0x96b6,
            0xe8af: 0x96b8,
            0xe8b0: 0x96b9,
            0xe8b1: 0x96ce,
            0xe8b2: 0x96cb,
            0xe8b3: 0x96c9,
            0xe8b4: 0x96cd,
            0xe8b5: 0x894d,
            0xe8b6: 0x96dc,
            0xe8b7: 0x970d,
            0xe8b8: 0x96d5,
            0xe8b9: 0x96f9,
            0xe8ba: 0x9704,
            0xe8bb: 0x9706,
            0xe8bc: 0x9708,
            0xe8bd: 0x9713,
            0xe8be: 0x970e,
            0xe8bf: 0x9711,
            0xe8c0: 0x970f,
            0xe8c1: 0x9716,
            0xe8c2: 0x9719,
            0xe8c3: 0x9724,
            0xe8c4: 0x972a,
            0xe8c5: 0x9730,
            0xe8c6: 0x9739,
            0xe8c7: 0x973d,
            0xe8c8: 0x973e,
            0xe8c9: 0x9744,
            0xe8ca: 0x9746,
            0xe8cb: 0x9748,
            0xe8cc: 0x9742,
            0xe8cd: 0x9749,
            0xe8ce: 0x975c,
            0xe8cf: 0x9760,
            0xe8d0: 0x9764,
            0xe8d1: 0x9766,
            0xe8d2: 0x9768,
            0xe8d3: 0x52d2,
            0xe8d4: 0x976b,
            0xe8d5: 0x9771,
            0xe8d6: 0x9779,
            0xe8d7: 0x9785,
            0xe8d8: 0x977c,
            0xe8d9: 0x9781,
            0xe8da: 0x977a,
            0xe8db: 0x9786,
            0xe8dc: 0x978b,
            0xe8dd: 0x978f,
            0xe8de: 0x9790,
            0xe8df: 0x979c,
            0xe8e0: 0x97a8,
            0xe8e1: 0x97a6,
            0xe8e2: 0x97a3,
            0xe8e3: 0x97b3,
            0xe8e4: 0x97b4,
            0xe8e5: 0x97c3,
            0xe8e6: 0x97c6,
            0xe8e7: 0x97c8,
            0xe8e8: 0x97cb,
            0xe8e9: 0x97dc,
            0xe8ea: 0x97ed,
            0xe8eb: 0x9f4f,
            0xe8ec: 0x97f2,
            0xe8ed: 0x7adf,
            0xe8ee: 0x97f6,
            0xe8ef: 0x97f5,
            0xe8f0: 0x980f,
            0xe8f1: 0x980c,
            0xe8f2: 0x9838,
            0xe8f3: 0x9824,
            0xe8f4: 0x9821,
            0xe8f5: 0x9837,
            0xe8f6: 0x983d,
            0xe8f7: 0x9846,
            0xe8f8: 0x984f,
            0xe8f9: 0x984b,
            0xe8fa: 0x986b,
            0xe8fb: 0x986f,
            0xe8fc: 0x9870,
            0xe940: 0x9871,
            0xe941: 0x9874,
            0xe942: 0x9873,
            0xe943: 0x98aa,
            0xe944: 0x98af,
            0xe945: 0x98b1,
            0xe946: 0x98b6,
            0xe947: 0x98c4,
            0xe948: 0x98c3,
            0xe949: 0x98c6,
            0xe94a: 0x98e9,
            0xe94b: 0x98eb,
            0xe94c: 0x9903,
            0xe94d: 0x9909,
            0xe94e: 0x9912,
            0xe94f: 0x9914,
            0xe950: 0x9918,
            0xe951: 0x9921,
            0xe952: 0x991d,
            0xe953: 0x991e,
            0xe954: 0x9924,
            0xe955: 0x9920,
            0xe956: 0x992c,
            0xe957: 0x992e,
            0xe958: 0x993d,
            0xe959: 0x993e,
            0xe95a: 0x9942,
            0xe95b: 0x9949,
            0xe95c: 0x9945,
            0xe95d: 0x9950,
            0xe95e: 0x994b,
            0xe95f: 0x9951,
            0xe960: 0x9952,
            0xe961: 0x994c,
            0xe962: 0x9955,
            0xe963: 0x9997,
            0xe964: 0x9998,
            0xe965: 0x99a5,
            0xe966: 0x99ad,
            0xe967: 0x99ae,
            0xe968: 0x99bc,
            0xe969: 0x99df,
            0xe96a: 0x99db,
            0xe96b: 0x99dd,
            0xe96c: 0x99d8,
            0xe96d: 0x99d1,
            0xe96e: 0x99ed,
            0xe96f: 0x99ee,
            0xe970: 0x99f1,
            0xe971: 0x99f2,
            0xe972: 0x99fb,
            0xe973: 0x99f8,
            0xe974: 0x9a01,
            0xe975: 0x9a0f,
            0xe976: 0x9a05,
            0xe977: 0x99e2,
            0xe978: 0x9a19,
            0xe979: 0x9a2b,
            0xe97a: 0x9a37,
            0xe97b: 0x9a45,
            0xe97c: 0x9a42,
            0xe97d: 0x9a40,
            0xe97e: 0x9a43,
            0xe980: 0x9a3e,
            0xe981: 0x9a55,
            0xe982: 0x9a4d,
            0xe983: 0x9a5b,
            0xe984: 0x9a57,
            0xe985: 0x9a5f,
            0xe986: 0x9a62,
            0xe987: 0x9a65,
            0xe988: 0x9a64,
            0xe989: 0x9a69,
            0xe98a: 0x9a6b,
            0xe98b: 0x9a6a,
            0xe98c: 0x9aad,
            0xe98d: 0x9ab0,
            0xe98e: 0x9abc,
            0xe98f: 0x9ac0,
            0xe990: 0x9acf,
            0xe991: 0x9ad1,
            0xe992: 0x9ad3,
            0xe993: 0x9ad4,
            0xe994: 0x9ade,
            0xe995: 0x9adf,
            0xe996: 0x9ae2,
            0xe997: 0x9ae3,
            0xe998: 0x9ae6,
            0xe999: 0x9aef,
            0xe99a: 0x9aeb,
            0xe99b: 0x9aee,
            0xe99c: 0x9af4,
            0xe99d: 0x9af1,
            0xe99e: 0x9af7,
            0xe99f: 0x9afb,
            0xe9a0: 0x9b06,
            0xe9a1: 0x9b18,
            0xe9a2: 0x9b1a,
            0xe9a3: 0x9b1f,
            0xe9a4: 0x9b22,
            0xe9a5: 0x9b23,
            0xe9a6: 0x9b25,
            0xe9a7: 0x9b27,
            0xe9a8: 0x9b28,
            0xe9a9: 0x9b29,
            0xe9aa: 0x9b2a,
            0xe9ab: 0x9b2e,
            0xe9ac: 0x9b2f,
            0xe9ad: 0x9b32,
            0xe9ae: 0x9b44,
            0xe9af: 0x9b43,
            0xe9b0: 0x9b4f,
            0xe9b1: 0x9b4d,
            0xe9b2: 0x9b4e,
            0xe9b3: 0x9b51,
            0xe9b4: 0x9b58,
            0xe9b5: 0x9b74,
            0xe9b6: 0x9b93,
            0xe9b7: 0x9b83,
            0xe9b8: 0x9b91,
            0xe9b9: 0x9b96,
            0xe9ba: 0x9b97,
            0xe9bb: 0x9b9f,
            0xe9bc: 0x9ba0,
            0xe9bd: 0x9ba8,
            0xe9be: 0x9bb4,
            0xe9bf: 0x9bc0,
            0xe9c0: 0x9bca,
            0xe9c1: 0x9bb9,
            0xe9c2: 0x9bc6,
            0xe9c3: 0x9bcf,
            0xe9c4: 0x9bd1,
            0xe9c5: 0x9bd2,
            0xe9c6: 0x9be3,
            0xe9c7: 0x9be2,
            0xe9c8: 0x9be4,
            0xe9c9: 0x9bd4,
            0xe9ca: 0x9be1,
            0xe9cb: 0x9c3a,
            0xe9cc: 0x9bf2,
            0xe9cd: 0x9bf1,
            0xe9ce: 0x9bf0,
            0xe9cf: 0x9c15,
            0xe9d0: 0x9c14,
            0xe9d1: 0x9c09,
            0xe9d2: 0x9c13,
            0xe9d3: 0x9c0c,
            0xe9d4: 0x9c06,
            0xe9d5: 0x9c08,
            0xe9d6: 0x9c12,
            0xe9d7: 0x9c0a,
            0xe9d8: 0x9c04,
            0xe9d9: 0x9c2e,
            0xe9da: 0x9c1b,
            0xe9db: 0x9c25,
            0xe9dc: 0x9c24,
            0xe9dd: 0x9c21,
            0xe9de: 0x9c30,
            0xe9df: 0x9c47,
            0xe9e0: 0x9c32,
            0xe9e1: 0x9c46,
            0xe9e2: 0x9c3e,
            0xe9e3: 0x9c5a,
            0xe9e4: 0x9c60,
            0xe9e5: 0x9c67,
            0xe9e6: 0x9c76,
            0xe9e7: 0x9c78,
            0xe9e8: 0x9ce7,
            0xe9e9: 0x9cec,
            0xe9ea: 0x9cf0,
            0xe9eb: 0x9d09,
            0xe9ec: 0x9d08,
            0xe9ed: 0x9ceb,
            0xe9ee: 0x9d03,
            0xe9ef: 0x9d06,
            0xe9f0: 0x9d2a,
            0xe9f1: 0x9d26,
            0xe9f2: 0x9daf,
            0xe9f3: 0x9d23,
            0xe9f4: 0x9d1f,
            0xe9f5: 0x9d44,
            0xe9f6: 0x9d15,
            0xe9f7: 0x9d12,
            0xe9f8: 0x9d41,
            0xe9f9: 0x9d3f,
            0xe9fa: 0x9d3e,
            0xe9fb: 0x9d46,
            0xe9fc: 0x9d48,
            0xea40: 0x9d5d,
            0xea41: 0x9d5e,
            0xea42: 0x9d64,
            0xea43: 0x9d51,
            0xea44: 0x9d50,
            0xea45: 0x9d59,
            0xea46: 0x9d72,
            0xea47: 0x9d89,
            0xea48: 0x9d87,
            0xea49: 0x9dab,
            0xea4a: 0x9d6f,
            0xea4b: 0x9d7a,
            0xea4c: 0x9d9a,
            0xea4d: 0x9da4,
            0xea4e: 0x9da9,
            0xea4f: 0x9db2,
            0xea50: 0x9dc4,
            0xea51: 0x9dc1,
            0xea52: 0x9dbb,
            0xea53: 0x9db8,
            0xea54: 0x9dba,
            0xea55: 0x9dc6,
            0xea56: 0x9dcf,
            0xea57: 0x9dc2,
            0xea58: 0x9dd9,
            0xea59: 0x9dd3,
            0xea5a: 0x9df8,
            0xea5b: 0x9de6,
            0xea5c: 0x9ded,
            0xea5d: 0x9def,
            0xea5e: 0x9dfd,
            0xea5f: 0x9e1a,
            0xea60: 0x9e1b,
            0xea61: 0x9e1e,
            0xea62: 0x9e75,
            0xea63: 0x9e79,
            0xea64: 0x9e7d,
            0xea65: 0x9e81,
            0xea66: 0x9e88,
            0xea67: 0x9e8b,
            0xea68: 0x9e8c,
            0xea69: 0x9e92,
            0xea6a: 0x9e95,
            0xea6b: 0x9e91,
            0xea6c: 0x9e9d,
            0xea6d: 0x9ea5,
            0xea6e: 0x9ea9,
            0xea6f: 0x9eb8,
            0xea70: 0x9eaa,
            0xea71: 0x9ead,
            0xea72: 0x9761,
            0xea73: 0x9ecc,
            0xea74: 0x9ece,
            0xea75: 0x9ecf,
            0xea76: 0x9ed0,
            0xea77: 0x9ed4,
            0xea78: 0x9edc,
            0xea79: 0x9ede,
            0xea7a: 0x9edd,
            0xea7b: 0x9ee0,
            0xea7c: 0x9ee5,
            0xea7d: 0x9ee8,
            0xea7e: 0x9eef,
            0xea80: 0x9ef4,
            0xea81: 0x9ef6,
            0xea82: 0x9ef7,
            0xea83: 0x9ef9,
            0xea84: 0x9efb,
            0xea85: 0x9efc,
            0xea86: 0x9efd,
            0xea87: 0x9f07,
            0xea88: 0x9f08,
            0xea89: 0x76b7,
            0xea8a: 0x9f15,
            0xea8b: 0x9f21,
            0xea8c: 0x9f2c,
            0xea8d: 0x9f3e,
            0xea8e: 0x9f4a,
            0xea8f: 0x9f52,
            0xea90: 0x9f54,
            0xea91: 0x9f63,
            0xea92: 0x9f5f,
            0xea93: 0x9f60,
            0xea94: 0x9f61,
            0xea95: 0x9f66,
            0xea96: 0x9f67,
            0xea97: 0x9f6c,
            0xea98: 0x9f6a,
            0xea99: 0x9f77,
            0xea9a: 0x9f72,
            0xea9b: 0x9f76,
            0xea9c: 0x9f95,
            0xea9d: 0x9f9c,
            0xea9e: 0x9fa0,
            0xea9f: 0x582f,
            0xeaa0: 0x69c7,
            0xeaa1: 0x9059,
            0xeaa2: 0x7464,
            0xeaa3: 0x51dc,
            0xeaa4: 0x7199,
          };
  
          /***/
        },
        /* 9 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var GenericGF_1 = __webpack_require__(1);
          var GenericGFPoly_1 = __webpack_require__(2);
          function runEuclideanAlgorithm(field, a, b, R) {
            var _a;
            // Assume a's degree is >= b's
            if (a.degree() < b.degree()) {
              (_a = [b, a]), (a = _a[0]), (b = _a[1]);
            }
            var rLast = a;
            var r = b;
            var tLast = field.zero;
            var t = field.one;
            // Run Euclidean algorithm until r's degree is less than R/2
            while (r.degree() >= R / 2) {
              var rLastLast = rLast;
              var tLastLast = tLast;
              rLast = r;
              tLast = t;
              // Divide rLastLast by rLast, with quotient in q and remainder in r
              if (rLast.isZero()) {
                // Euclidean algorithm already terminated?
                return null;
              }
              r = rLastLast;
              var q = field.zero;
              var denominatorLeadingTerm = rLast.getCoefficient(rLast.degree());
              var dltInverse = field.inverse(denominatorLeadingTerm);
              while (r.degree() >= rLast.degree() && !r.isZero()) {
                var degreeDiff = r.degree() - rLast.degree();
                var scale = field.multiply(
                  r.getCoefficient(r.degree()),
                  dltInverse
                );
                q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));
                r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));
              }
              t = q.multiplyPoly(tLast).addOrSubtract(tLastLast);
              if (r.degree() >= rLast.degree()) {
                return null;
              }
            }
            var sigmaTildeAtZero = t.getCoefficient(0);
            if (sigmaTildeAtZero === 0) {
              return null;
            }
            var inverse = field.inverse(sigmaTildeAtZero);
            return [t.multiply(inverse), r.multiply(inverse)];
          }
          function findErrorLocations(field, errorLocator) {
            // This is a direct application of Chien's search
            var numErrors = errorLocator.degree();
            if (numErrors === 1) {
              return [errorLocator.getCoefficient(1)];
            }
            var result = new Array(numErrors);
            var errorCount = 0;
            for (var i = 1; i < field.size && errorCount < numErrors; i++) {
              if (errorLocator.evaluateAt(i) === 0) {
                result[errorCount] = field.inverse(i);
                errorCount++;
              }
            }
            if (errorCount !== numErrors) {
              return null;
            }
            return result;
          }
          function findErrorMagnitudes(field, errorEvaluator, errorLocations) {
            // This is directly applying Forney's Formula
            var s = errorLocations.length;
            var result = new Array(s);
            for (var i = 0; i < s; i++) {
              var xiInverse = field.inverse(errorLocations[i]);
              var denominator = 1;
              for (var j = 0; j < s; j++) {
                if (i !== j) {
                  denominator = field.multiply(
                    denominator,
                    GenericGF_1.addOrSubtractGF(
                      1,
                      field.multiply(errorLocations[j], xiInverse)
                    )
                  );
                }
              }
              result[i] = field.multiply(
                errorEvaluator.evaluateAt(xiInverse),
                field.inverse(denominator)
              );
              if (field.generatorBase !== 0) {
                result[i] = field.multiply(result[i], xiInverse);
              }
            }
            return result;
          }
          function decode(bytes, twoS) {
            var outputBytes = new Uint8ClampedArray(bytes.length);
            outputBytes.set(bytes);
            var field = new GenericGF_1.default(0x011d, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1
            var poly = new GenericGFPoly_1.default(field, outputBytes);
            var syndromeCoefficients = new Uint8ClampedArray(twoS);
            var error = false;
            for (var s = 0; s < twoS; s++) {
              var evaluation = poly.evaluateAt(
                field.exp(s + field.generatorBase)
              );
              syndromeCoefficients[
                syndromeCoefficients.length - 1 - s
              ] = evaluation;
              if (evaluation !== 0) {
                error = true;
              }
            }
            if (!error) {
              return outputBytes;
            }
            var syndrome = new GenericGFPoly_1.default(
              field,
              syndromeCoefficients
            );
            var sigmaOmega = runEuclideanAlgorithm(
              field,
              field.buildMonomial(twoS, 1),
              syndrome,
              twoS
            );
            if (sigmaOmega === null) {
              return null;
            }
            var errorLocations = findErrorLocations(field, sigmaOmega[0]);
            if (errorLocations == null) {
              return null;
            }
            var errorMagnitudes = findErrorMagnitudes(
              field,
              sigmaOmega[1],
              errorLocations
            );
            for (var i = 0; i < errorLocations.length; i++) {
              var position =
                outputBytes.length - 1 - field.log(errorLocations[i]);
              if (position < 0) {
                return null;
              }
              outputBytes[position] = GenericGF_1.addOrSubtractGF(
                outputBytes[position],
                errorMagnitudes[i]
              );
            }
            return outputBytes;
          }
          exports.decode = decode;
  
          /***/
        },
        /* 10 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          exports.VERSIONS = [
            {
              infoBits: null,
              versionNumber: 1,
              alignmentPatternCenters: [],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 7,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 19 }],
                },
                {
                  ecCodewordsPerBlock: 10,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 16 }],
                },
                {
                  ecCodewordsPerBlock: 13,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 13 }],
                },
                {
                  ecCodewordsPerBlock: 17,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 9 }],
                },
              ],
            },
            {
              infoBits: null,
              versionNumber: 2,
              alignmentPatternCenters: [6, 18],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 10,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 34 }],
                },
                {
                  ecCodewordsPerBlock: 16,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 28 }],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 22 }],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 16 }],
                },
              ],
            },
            {
              infoBits: null,
              versionNumber: 3,
              alignmentPatternCenters: [6, 22],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 15,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 55 }],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 44 }],
                },
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 17 }],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 13 }],
                },
              ],
            },
            {
              infoBits: null,
              versionNumber: 4,
              alignmentPatternCenters: [6, 26],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 20,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 80 }],
                },
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 32 }],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 24 }],
                },
                {
                  ecCodewordsPerBlock: 16,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 9 }],
                },
              ],
            },
            {
              infoBits: null,
              versionNumber: 5,
              alignmentPatternCenters: [6, 30],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 108 }],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 43 }],
                },
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                    { numBlocks: 2, dataCodewordsPerBlock: 16 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 11 },
                    { numBlocks: 2, dataCodewordsPerBlock: 12 },
                  ],
                },
              ],
            },
            {
              infoBits: null,
              versionNumber: 6,
              alignmentPatternCenters: [6, 34],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 68 }],
                },
                {
                  ecCodewordsPerBlock: 16,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 27 }],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 19 }],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 15 }],
                },
              ],
            },
            {
              infoBits: 0x07c94,
              versionNumber: 7,
              alignmentPatternCenters: [6, 22, 38],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 20,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 78 }],
                },
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 31 }],
                },
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                    { numBlocks: 4, dataCodewordsPerBlock: 15 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 13 },
                    { numBlocks: 1, dataCodewordsPerBlock: 14 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x085bc,
              versionNumber: 8,
              alignmentPatternCenters: [6, 24, 42],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 97 }],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 38 },
                    { numBlocks: 2, dataCodewordsPerBlock: 39 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 18 },
                    { numBlocks: 2, dataCodewordsPerBlock: 19 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 14 },
                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x09a99,
              versionNumber: 9,
              alignmentPatternCenters: [6, 26, 46],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 116 }],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 36 },
                    { numBlocks: 2, dataCodewordsPerBlock: 37 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 20,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 16 },
                    { numBlocks: 4, dataCodewordsPerBlock: 17 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 12 },
                    { numBlocks: 4, dataCodewordsPerBlock: 13 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0a4d3,
              versionNumber: 10,
              alignmentPatternCenters: [6, 28, 50],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 18,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 68 },
                    { numBlocks: 2, dataCodewordsPerBlock: 69 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 43 },
                    { numBlocks: 1, dataCodewordsPerBlock: 44 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 19 },
                    { numBlocks: 2, dataCodewordsPerBlock: 20 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 15 },
                    { numBlocks: 2, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0bbf6,
              versionNumber: 11,
              alignmentPatternCenters: [6, 30, 54],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 20,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 81 }],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 1, dataCodewordsPerBlock: 50 },
                    { numBlocks: 4, dataCodewordsPerBlock: 51 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 22 },
                    { numBlocks: 4, dataCodewordsPerBlock: 23 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 12 },
                    { numBlocks: 8, dataCodewordsPerBlock: 13 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0c762,
              versionNumber: 12,
              alignmentPatternCenters: [6, 32, 58],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 92 },
                    { numBlocks: 2, dataCodewordsPerBlock: 93 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 36 },
                    { numBlocks: 2, dataCodewordsPerBlock: 37 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 20 },
                    { numBlocks: 6, dataCodewordsPerBlock: 21 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 7, dataCodewordsPerBlock: 14 },
                    { numBlocks: 4, dataCodewordsPerBlock: 15 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0d847,
              versionNumber: 13,
              alignmentPatternCenters: [6, 34, 62],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 107 }],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 37 },
                    { numBlocks: 1, dataCodewordsPerBlock: 38 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 20 },
                    { numBlocks: 4, dataCodewordsPerBlock: 21 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 12, dataCodewordsPerBlock: 11 },
                    { numBlocks: 4, dataCodewordsPerBlock: 12 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0e60d,
              versionNumber: 14,
              alignmentPatternCenters: [6, 26, 46, 66],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 115 },
                    { numBlocks: 1, dataCodewordsPerBlock: 116 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 40 },
                    { numBlocks: 5, dataCodewordsPerBlock: 41 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 20,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 16 },
                    { numBlocks: 5, dataCodewordsPerBlock: 17 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 12 },
                    { numBlocks: 5, dataCodewordsPerBlock: 13 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x0f928,
              versionNumber: 15,
              alignmentPatternCenters: [6, 26, 48, 70],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 22,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 87 },
                    { numBlocks: 1, dataCodewordsPerBlock: 88 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 41 },
                    { numBlocks: 5, dataCodewordsPerBlock: 42 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 24 },
                    { numBlocks: 7, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 12 },
                    { numBlocks: 7, dataCodewordsPerBlock: 13 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x10b78,
              versionNumber: 16,
              alignmentPatternCenters: [6, 26, 50, 74],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 98 },
                    { numBlocks: 1, dataCodewordsPerBlock: 99 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 7, dataCodewordsPerBlock: 45 },
                    { numBlocks: 3, dataCodewordsPerBlock: 46 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [
                    { numBlocks: 15, dataCodewordsPerBlock: 19 },
                    { numBlocks: 2, dataCodewordsPerBlock: 20 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 15 },
                    { numBlocks: 13, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1145d,
              versionNumber: 17,
              alignmentPatternCenters: [6, 30, 54, 78],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 1, dataCodewordsPerBlock: 107 },
                    { numBlocks: 5, dataCodewordsPerBlock: 108 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 10, dataCodewordsPerBlock: 46 },
                    { numBlocks: 1, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 1, dataCodewordsPerBlock: 22 },
                    { numBlocks: 15, dataCodewordsPerBlock: 23 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                    { numBlocks: 17, dataCodewordsPerBlock: 15 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x12a17,
              versionNumber: 18,
              alignmentPatternCenters: [6, 30, 56, 82],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 120 },
                    { numBlocks: 1, dataCodewordsPerBlock: 121 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 9, dataCodewordsPerBlock: 43 },
                    { numBlocks: 4, dataCodewordsPerBlock: 44 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 17, dataCodewordsPerBlock: 22 },
                    { numBlocks: 1, dataCodewordsPerBlock: 23 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                    { numBlocks: 19, dataCodewordsPerBlock: 15 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x13532,
              versionNumber: 19,
              alignmentPatternCenters: [6, 30, 58, 86],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 113 },
                    { numBlocks: 4, dataCodewordsPerBlock: 114 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 44 },
                    { numBlocks: 11, dataCodewordsPerBlock: 45 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 17, dataCodewordsPerBlock: 21 },
                    { numBlocks: 4, dataCodewordsPerBlock: 22 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 9, dataCodewordsPerBlock: 13 },
                    { numBlocks: 16, dataCodewordsPerBlock: 14 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x149a6,
              versionNumber: 20,
              alignmentPatternCenters: [6, 34, 62, 90],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 107 },
                    { numBlocks: 5, dataCodewordsPerBlock: 108 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 41 },
                    { numBlocks: 13, dataCodewordsPerBlock: 42 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 15, dataCodewordsPerBlock: 24 },
                    { numBlocks: 5, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 15, dataCodewordsPerBlock: 15 },
                    { numBlocks: 10, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x15683,
              versionNumber: 21,
              alignmentPatternCenters: [6, 28, 50, 72, 94],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 116 },
                    { numBlocks: 4, dataCodewordsPerBlock: 117 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 42 }],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 17, dataCodewordsPerBlock: 22 },
                    { numBlocks: 6, dataCodewordsPerBlock: 23 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 16 },
                    { numBlocks: 6, dataCodewordsPerBlock: 17 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x168c9,
              versionNumber: 22,
              alignmentPatternCenters: [6, 26, 50, 74, 98],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 111 },
                    { numBlocks: 7, dataCodewordsPerBlock: 112 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 46 }],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 7, dataCodewordsPerBlock: 24 },
                    { numBlocks: 16, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 24,
                  ecBlocks: [{ numBlocks: 34, dataCodewordsPerBlock: 13 }],
                },
              ],
            },
            {
              infoBits: 0x177ec,
              versionNumber: 23,
              alignmentPatternCenters: [6, 30, 54, 74, 102],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 121 },
                    { numBlocks: 5, dataCodewordsPerBlock: 122 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 47 },
                    { numBlocks: 14, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 24 },
                    { numBlocks: 14, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 16, dataCodewordsPerBlock: 15 },
                    { numBlocks: 14, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x18ec4,
              versionNumber: 24,
              alignmentPatternCenters: [6, 28, 54, 80, 106],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 117 },
                    { numBlocks: 4, dataCodewordsPerBlock: 118 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 45 },
                    { numBlocks: 14, dataCodewordsPerBlock: 46 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 24 },
                    { numBlocks: 16, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 30, dataCodewordsPerBlock: 16 },
                    { numBlocks: 2, dataCodewordsPerBlock: 17 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x191e1,
              versionNumber: 25,
              alignmentPatternCenters: [6, 32, 58, 84, 110],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 26,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 106 },
                    { numBlocks: 4, dataCodewordsPerBlock: 107 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 47 },
                    { numBlocks: 13, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 7, dataCodewordsPerBlock: 24 },
                    { numBlocks: 22, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 22, dataCodewordsPerBlock: 15 },
                    { numBlocks: 13, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1afab,
              versionNumber: 26,
              alignmentPatternCenters: [6, 30, 58, 86, 114],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 10, dataCodewordsPerBlock: 114 },
                    { numBlocks: 2, dataCodewordsPerBlock: 115 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 46 },
                    { numBlocks: 4, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 28, dataCodewordsPerBlock: 22 },
                    { numBlocks: 6, dataCodewordsPerBlock: 23 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 33, dataCodewordsPerBlock: 16 },
                    { numBlocks: 4, dataCodewordsPerBlock: 17 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1b08e,
              versionNumber: 27,
              alignmentPatternCenters: [6, 34, 62, 90, 118],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 122 },
                    { numBlocks: 4, dataCodewordsPerBlock: 123 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 22, dataCodewordsPerBlock: 45 },
                    { numBlocks: 3, dataCodewordsPerBlock: 46 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 8, dataCodewordsPerBlock: 23 },
                    { numBlocks: 26, dataCodewordsPerBlock: 24 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 12, dataCodewordsPerBlock: 15 },
                    { numBlocks: 28, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1cc1a,
              versionNumber: 28,
              alignmentPatternCenters: [6, 26, 50, 74, 98, 122],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 117 },
                    { numBlocks: 10, dataCodewordsPerBlock: 118 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 3, dataCodewordsPerBlock: 45 },
                    { numBlocks: 23, dataCodewordsPerBlock: 46 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 24 },
                    { numBlocks: 31, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 15 },
                    { numBlocks: 31, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1d33f,
              versionNumber: 29,
              alignmentPatternCenters: [6, 30, 54, 78, 102, 126],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 7, dataCodewordsPerBlock: 116 },
                    { numBlocks: 7, dataCodewordsPerBlock: 117 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 21, dataCodewordsPerBlock: 45 },
                    { numBlocks: 7, dataCodewordsPerBlock: 46 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 1, dataCodewordsPerBlock: 23 },
                    { numBlocks: 37, dataCodewordsPerBlock: 24 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 15 },
                    { numBlocks: 26, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1ed75,
              versionNumber: 30,
              alignmentPatternCenters: [6, 26, 52, 78, 104, 130],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 5, dataCodewordsPerBlock: 115 },
                    { numBlocks: 10, dataCodewordsPerBlock: 116 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 47 },
                    { numBlocks: 10, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 15, dataCodewordsPerBlock: 24 },
                    { numBlocks: 25, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 23, dataCodewordsPerBlock: 15 },
                    { numBlocks: 25, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x1f250,
              versionNumber: 31,
              alignmentPatternCenters: [6, 30, 56, 82, 108, 134],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 13, dataCodewordsPerBlock: 115 },
                    { numBlocks: 3, dataCodewordsPerBlock: 116 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 46 },
                    { numBlocks: 29, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 42, dataCodewordsPerBlock: 24 },
                    { numBlocks: 1, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 23, dataCodewordsPerBlock: 15 },
                    { numBlocks: 28, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x209d5,
              versionNumber: 32,
              alignmentPatternCenters: [6, 34, 60, 86, 112, 138],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 115 }],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 10, dataCodewordsPerBlock: 46 },
                    { numBlocks: 23, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 10, dataCodewordsPerBlock: 24 },
                    { numBlocks: 35, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 15 },
                    { numBlocks: 35, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x216f0,
              versionNumber: 33,
              alignmentPatternCenters: [6, 30, 58, 86, 114, 142],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 17, dataCodewordsPerBlock: 115 },
                    { numBlocks: 1, dataCodewordsPerBlock: 116 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 14, dataCodewordsPerBlock: 46 },
                    { numBlocks: 21, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 29, dataCodewordsPerBlock: 24 },
                    { numBlocks: 19, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 11, dataCodewordsPerBlock: 15 },
                    { numBlocks: 46, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x228ba,
              versionNumber: 34,
              alignmentPatternCenters: [6, 34, 62, 90, 118, 146],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 13, dataCodewordsPerBlock: 115 },
                    { numBlocks: 6, dataCodewordsPerBlock: 116 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 14, dataCodewordsPerBlock: 46 },
                    { numBlocks: 23, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 44, dataCodewordsPerBlock: 24 },
                    { numBlocks: 7, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 59, dataCodewordsPerBlock: 16 },
                    { numBlocks: 1, dataCodewordsPerBlock: 17 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x2379f,
              versionNumber: 35,
              alignmentPatternCenters: [6, 30, 54, 78, 102, 126, 150],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 12, dataCodewordsPerBlock: 121 },
                    { numBlocks: 7, dataCodewordsPerBlock: 122 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 12, dataCodewordsPerBlock: 47 },
                    { numBlocks: 26, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 39, dataCodewordsPerBlock: 24 },
                    { numBlocks: 14, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 22, dataCodewordsPerBlock: 15 },
                    { numBlocks: 41, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x24b0b,
              versionNumber: 36,
              alignmentPatternCenters: [6, 24, 50, 76, 102, 128, 154],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 121 },
                    { numBlocks: 14, dataCodewordsPerBlock: 122 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 6, dataCodewordsPerBlock: 47 },
                    { numBlocks: 34, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 46, dataCodewordsPerBlock: 24 },
                    { numBlocks: 10, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                    { numBlocks: 64, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x2542e,
              versionNumber: 37,
              alignmentPatternCenters: [6, 28, 54, 80, 106, 132, 158],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 17, dataCodewordsPerBlock: 122 },
                    { numBlocks: 4, dataCodewordsPerBlock: 123 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 29, dataCodewordsPerBlock: 46 },
                    { numBlocks: 14, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 49, dataCodewordsPerBlock: 24 },
                    { numBlocks: 10, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 24, dataCodewordsPerBlock: 15 },
                    { numBlocks: 46, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x26a64,
              versionNumber: 38,
              alignmentPatternCenters: [6, 32, 58, 84, 110, 136, 162],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 4, dataCodewordsPerBlock: 122 },
                    { numBlocks: 18, dataCodewordsPerBlock: 123 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 13, dataCodewordsPerBlock: 46 },
                    { numBlocks: 32, dataCodewordsPerBlock: 47 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 48, dataCodewordsPerBlock: 24 },
                    { numBlocks: 14, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 42, dataCodewordsPerBlock: 15 },
                    { numBlocks: 32, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x27541,
              versionNumber: 39,
              alignmentPatternCenters: [6, 26, 54, 82, 110, 138, 166],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 20, dataCodewordsPerBlock: 117 },
                    { numBlocks: 4, dataCodewordsPerBlock: 118 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 40, dataCodewordsPerBlock: 47 },
                    { numBlocks: 7, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 43, dataCodewordsPerBlock: 24 },
                    { numBlocks: 22, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 10, dataCodewordsPerBlock: 15 },
                    { numBlocks: 67, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
            {
              infoBits: 0x28c69,
              versionNumber: 40,
              alignmentPatternCenters: [6, 30, 58, 86, 114, 142, 170],
              errorCorrectionLevels: [
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 19, dataCodewordsPerBlock: 118 },
                    { numBlocks: 6, dataCodewordsPerBlock: 119 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 28,
                  ecBlocks: [
                    { numBlocks: 18, dataCodewordsPerBlock: 47 },
                    { numBlocks: 31, dataCodewordsPerBlock: 48 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 34, dataCodewordsPerBlock: 24 },
                    { numBlocks: 34, dataCodewordsPerBlock: 25 },
                  ],
                },
                {
                  ecCodewordsPerBlock: 30,
                  ecBlocks: [
                    { numBlocks: 20, dataCodewordsPerBlock: 15 },
                    { numBlocks: 61, dataCodewordsPerBlock: 16 },
                  ],
                },
              ],
            },
          ];
  
          /***/
        },
        /* 11 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var BitMatrix_1 = __webpack_require__(0);
          function squareToQuadrilateral(p1, p2, p3, p4) {
            var dx3 = p1.x - p2.x + p3.x - p4.x;
            var dy3 = p1.y - p2.y + p3.y - p4.y;
            if (dx3 === 0 && dy3 === 0) {
              // Affine
              return {
                a11: p2.x - p1.x,
                a12: p2.y - p1.y,
                a13: 0,
                a21: p3.x - p2.x,
                a22: p3.y - p2.y,
                a23: 0,
                a31: p1.x,
                a32: p1.y,
                a33: 1,
              };
            } else {
              var dx1 = p2.x - p3.x;
              var dx2 = p4.x - p3.x;
              var dy1 = p2.y - p3.y;
              var dy2 = p4.y - p3.y;
              var denominator = dx1 * dy2 - dx2 * dy1;
              var a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
              var a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
              return {
                a11: p2.x - p1.x + a13 * p2.x,
                a12: p2.y - p1.y + a13 * p2.y,
                a13: a13,
                a21: p4.x - p1.x + a23 * p4.x,
                a22: p4.y - p1.y + a23 * p4.y,
                a23: a23,
                a31: p1.x,
                a32: p1.y,
                a33: 1,
              };
            }
          }
          function quadrilateralToSquare(p1, p2, p3, p4) {
            // Here, the adjoint serves as the inverse:
            var sToQ = squareToQuadrilateral(p1, p2, p3, p4);
            return {
              a11: sToQ.a22 * sToQ.a33 - sToQ.a23 * sToQ.a32,
              a12: sToQ.a13 * sToQ.a32 - sToQ.a12 * sToQ.a33,
              a13: sToQ.a12 * sToQ.a23 - sToQ.a13 * sToQ.a22,
              a21: sToQ.a23 * sToQ.a31 - sToQ.a21 * sToQ.a33,
              a22: sToQ.a11 * sToQ.a33 - sToQ.a13 * sToQ.a31,
              a23: sToQ.a13 * sToQ.a21 - sToQ.a11 * sToQ.a23,
              a31: sToQ.a21 * sToQ.a32 - sToQ.a22 * sToQ.a31,
              a32: sToQ.a12 * sToQ.a31 - sToQ.a11 * sToQ.a32,
              a33: sToQ.a11 * sToQ.a22 - sToQ.a12 * sToQ.a21,
            };
          }
          function times(a, b) {
            return {
              a11: a.a11 * b.a11 + a.a21 * b.a12 + a.a31 * b.a13,
              a12: a.a12 * b.a11 + a.a22 * b.a12 + a.a32 * b.a13,
              a13: a.a13 * b.a11 + a.a23 * b.a12 + a.a33 * b.a13,
              a21: a.a11 * b.a21 + a.a21 * b.a22 + a.a31 * b.a23,
              a22: a.a12 * b.a21 + a.a22 * b.a22 + a.a32 * b.a23,
              a23: a.a13 * b.a21 + a.a23 * b.a22 + a.a33 * b.a23,
              a31: a.a11 * b.a31 + a.a21 * b.a32 + a.a31 * b.a33,
              a32: a.a12 * b.a31 + a.a22 * b.a32 + a.a32 * b.a33,
              a33: a.a13 * b.a31 + a.a23 * b.a32 + a.a33 * b.a33,
            };
          }
          function extract(image, location) {
            var qToS = quadrilateralToSquare(
              { x: 3.5, y: 3.5 },
              { x: location.dimension - 3.5, y: 3.5 },
              { x: location.dimension - 6.5, y: location.dimension - 6.5 },
              { x: 3.5, y: location.dimension - 3.5 }
            );
            var sToQ = squareToQuadrilateral(
              location.topLeft,
              location.topRight,
              location.alignmentPattern,
              location.bottomLeft
            );
            var transform = times(sToQ, qToS);
            var matrix = BitMatrix_1.BitMatrix.createEmpty(
              location.dimension,
              location.dimension
            );
            var mappingFunction = function (x, y) {
              var denominator =
                transform.a13 * x + transform.a23 * y + transform.a33;
              return {
                x:
                  (transform.a11 * x + transform.a21 * y + transform.a31) /
                  denominator,
                y:
                  (transform.a12 * x + transform.a22 * y + transform.a32) /
                  denominator,
              };
            };
            for (var y = 0; y < location.dimension; y++) {
              for (var x = 0; x < location.dimension; x++) {
                var xValue = x + 0.5;
                var yValue = y + 0.5;
                var sourcePixel = mappingFunction(xValue, yValue);
                matrix.set(
                  x,
                  y,
                  image.get(Math.floor(sourcePixel.x), Math.floor(sourcePixel.y))
                );
              }
            }
            return {
              matrix: matrix,
              mappingFunction: mappingFunction,
            };
          }
          exports.extract = extract;
  
          /***/
        },
        /* 12 */
        /***/ function (module, exports, __webpack_require__) {
          "use strict";
  
          Object.defineProperty(exports, "__esModule", { value: true });
          var MAX_FINDERPATTERNS_TO_SEARCH = 4;
          var MIN_QUAD_RATIO = 0.5;
          var MAX_QUAD_RATIO = 1.5;
          var distance = function (a, b) {
            return Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
          };
          function sum(values) {
            return values.reduce(function (a, b) {
              return a + b;
            });
          }
          // Takes three finder patterns and organizes them into topLeft, topRight, etc
          function reorderFinderPatterns(pattern1, pattern2, pattern3) {
            var _a, _b, _c, _d;
            // Find distances between pattern centers
            var oneTwoDistance = distance(pattern1, pattern2);
            var twoThreeDistance = distance(pattern2, pattern3);
            var oneThreeDistance = distance(pattern1, pattern3);
            var bottomLeft;
            var topLeft;
            var topRight;
            // Assume one closest to other two is B; A and C will just be guesses at first
            if (
              twoThreeDistance >= oneTwoDistance &&
              twoThreeDistance >= oneThreeDistance
            ) {
              (_a = [pattern2, pattern1, pattern3]),
                (bottomLeft = _a[0]),
                (topLeft = _a[1]),
                (topRight = _a[2]);
            } else if (
              oneThreeDistance >= twoThreeDistance &&
              oneThreeDistance >= oneTwoDistance
            ) {
              (_b = [pattern1, pattern2, pattern3]),
                (bottomLeft = _b[0]),
                (topLeft = _b[1]),
                (topRight = _b[2]);
            } else {
              (_c = [pattern1, pattern3, pattern2]),
                (bottomLeft = _c[0]),
                (topLeft = _c[1]),
                (topRight = _c[2]);
            }
            // Use cross product to figure out whether bottomLeft (A) and topRight (C) are correct or flipped in relation to topLeft (B)
            // This asks whether BC x BA has a positive z component, which is the arrangement we want. If it's negative, then
            // we've got it flipped around and should swap topRight and bottomLeft.
            if (
              (topRight.x - topLeft.x) * (bottomLeft.y - topLeft.y) -
                (topRight.y - topLeft.y) * (bottomLeft.x - topLeft.x) <
              0
            ) {
              (_d = [topRight, bottomLeft]),
                (bottomLeft = _d[0]),
                (topRight = _d[1]);
            }
            return {
              bottomLeft: bottomLeft,
              topLeft: topLeft,
              topRight: topRight,
            };
          }
          // Computes the dimension (number of modules on a side) of the QR Code based on the position of the finder patterns
          function computeDimension(topLeft, topRight, bottomLeft, matrix) {
            var moduleSize =
              (sum(countBlackWhiteRun(topLeft, bottomLeft, matrix, 5)) / 7 + // Divide by 7 since the ratio is 1:1:3:1:1
                sum(countBlackWhiteRun(topLeft, topRight, matrix, 5)) / 7 +
                sum(countBlackWhiteRun(bottomLeft, topLeft, matrix, 5)) / 7 +
                sum(countBlackWhiteRun(topRight, topLeft, matrix, 5)) / 7) /
              4;
            if (moduleSize < 1) {
              throw new Error("Invalid module size");
            }
            var topDimension = Math.round(
              distance(topLeft, topRight) / moduleSize
            );
            var sideDimension = Math.round(
              distance(topLeft, bottomLeft) / moduleSize
            );
            var dimension = Math.floor((topDimension + sideDimension) / 2) + 7;
            switch (dimension % 4) {
              case 0:
                dimension++;
                break;
              case 2:
                dimension--;
                break;
            }
            return { dimension: dimension, moduleSize: moduleSize };
          }
          // Takes an origin point and an end point and counts the sizes of the black white run from the origin towards the end point.
          // Returns an array of elements, representing the pixel size of the black white run.
          // Uses a variant of http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
          function countBlackWhiteRunTowardsPoint(origin, end, matrix, length) {
            var switchPoints = [
              { x: Math.floor(origin.x), y: Math.floor(origin.y) },
            ];
            var steep = Math.abs(end.y - origin.y) > Math.abs(end.x - origin.x);
            var fromX;
            var fromY;
            var toX;
            var toY;
            if (steep) {
              fromX = Math.floor(origin.y);
              fromY = Math.floor(origin.x);
              toX = Math.floor(end.y);
              toY = Math.floor(end.x);
            } else {
              fromX = Math.floor(origin.x);
              fromY = Math.floor(origin.y);
              toX = Math.floor(end.x);
              toY = Math.floor(end.y);
            }
            var dx = Math.abs(toX - fromX);
            var dy = Math.abs(toY - fromY);
            var error = Math.floor(-dx / 2);
            var xStep = fromX < toX ? 1 : -1;
            var yStep = fromY < toY ? 1 : -1;
            var currentPixel = true;
            // Loop up until x == toX, but not beyond
            for (var x = fromX, y = fromY; x !== toX + xStep; x += xStep) {
              // Does current pixel mean we have moved white to black or vice versa?
              // Scanning black in state 0,2 and white in state 1, so if we find the wrong
              // color, advance to next state or end if we are in state 2 already
              var realX = steep ? y : x;
              var realY = steep ? x : y;
              if (matrix.get(realX, realY) !== currentPixel) {
                currentPixel = !currentPixel;
                switchPoints.push({ x: realX, y: realY });
                if (switchPoints.length === length + 1) {
                  break;
                }
              }
              error += dy;
              if (error > 0) {
                if (y === toY) {
                  break;
                }
                y += yStep;
                error -= dx;
              }
            }
            var distances = [];
            for (var i = 0; i < length; i++) {
              if (switchPoints[i] && switchPoints[i + 1]) {
                distances.push(distance(switchPoints[i], switchPoints[i + 1]));
              } else {
                distances.push(0);
              }
            }
            return distances;
          }
          // Takes an origin point and an end point and counts the sizes of the black white run in the origin point
          // along the line that intersects with the end point. Returns an array of elements, representing the pixel sizes
          // of the black white run. Takes a length which represents the number of switches from black to white to look for.
          function countBlackWhiteRun(origin, end, matrix, length) {
            var _a;
            var rise = end.y - origin.y;
            var run = end.x - origin.x;
            var towardsEnd = countBlackWhiteRunTowardsPoint(
              origin,
              end,
              matrix,
              Math.ceil(length / 2)
            );
            var awayFromEnd = countBlackWhiteRunTowardsPoint(
              origin,
              { x: origin.x - run, y: origin.y - rise },
              matrix,
              Math.ceil(length / 2)
            );
            var middleValue = towardsEnd.shift() + awayFromEnd.shift() - 1; // Substract one so we don't double count a pixel
            return (_a = awayFromEnd.concat(middleValue)).concat.apply(
              _a,
              towardsEnd
            );
          }
          // Takes in a black white run and an array of expected ratios. Returns the average size of the run as well as the "error" -
          // that is the amount the run diverges from the expected ratio
          function scoreBlackWhiteRun(sequence, ratios) {
            var averageSize = sum(sequence) / sum(ratios);
            var error = 0;
            ratios.forEach(function (ratio, i) {
              error += Math.pow(sequence[i] - ratio * averageSize, 2);
            });
            return { averageSize: averageSize, error: error };
          }
          // Takes an X,Y point and an array of sizes and scores the point against those ratios.
          // For example for a finder pattern takes the ratio list of 1:1:3:1:1 and checks horizontal, vertical and diagonal ratios
          // against that.
          function scorePattern(point, ratios, matrix) {
            try {
              var horizontalRun = countBlackWhiteRun(
                point,
                { x: -1, y: point.y },
                matrix,
                ratios.length
              );
              var verticalRun = countBlackWhiteRun(
                point,
                { x: point.x, y: -1 },
                matrix,
                ratios.length
              );
              var topLeftPoint = {
                x: Math.max(0, point.x - point.y) - 1,
                y: Math.max(0, point.y - point.x) - 1,
              };
              var topLeftBottomRightRun = countBlackWhiteRun(
                point,
                topLeftPoint,
                matrix,
                ratios.length
              );
              var bottomLeftPoint = {
                x: Math.min(matrix.width, point.x + point.y) + 1,
                y: Math.min(matrix.height, point.y + point.x) + 1,
              };
              var bottomLeftTopRightRun = countBlackWhiteRun(
                point,
                bottomLeftPoint,
                matrix,
                ratios.length
              );
              var horzError = scoreBlackWhiteRun(horizontalRun, ratios);
              var vertError = scoreBlackWhiteRun(verticalRun, ratios);
              var diagDownError = scoreBlackWhiteRun(
                topLeftBottomRightRun,
                ratios
              );
              var diagUpError = scoreBlackWhiteRun(bottomLeftTopRightRun, ratios);
              var ratioError = Math.sqrt(
                horzError.error * horzError.error +
                  vertError.error * vertError.error +
                  diagDownError.error * diagDownError.error +
                  diagUpError.error * diagUpError.error
              );
              var avgSize =
                (horzError.averageSize +
                  vertError.averageSize +
                  diagDownError.averageSize +
                  diagUpError.averageSize) /
                4;
              var sizeError =
                (Math.pow(horzError.averageSize - avgSize, 2) +
                  Math.pow(vertError.averageSize - avgSize, 2) +
                  Math.pow(diagDownError.averageSize - avgSize, 2) +
                  Math.pow(diagUpError.averageSize - avgSize, 2)) /
                avgSize;
              return ratioError + sizeError;
            } catch (_a) {
              return Infinity;
            }
          }
          function recenterLocation(matrix, p) {
            var leftX = Math.round(p.x);
            while (matrix.get(leftX, Math.round(p.y))) {
              leftX--;
            }
            var rightX = Math.round(p.x);
            while (matrix.get(rightX, Math.round(p.y))) {
              rightX++;
            }
            var x = (leftX + rightX) / 2;
            var topY = Math.round(p.y);
            while (matrix.get(Math.round(x), topY)) {
              topY--;
            }
            var bottomY = Math.round(p.y);
            while (matrix.get(Math.round(x), bottomY)) {
              bottomY++;
            }
            var y = (topY + bottomY) / 2;
            return { x: x, y: y };
          }
          function locate(matrix) {
            var finderPatternQuads = [];
            var activeFinderPatternQuads = [];
            var alignmentPatternQuads = [];
            var activeAlignmentPatternQuads = [];
            var _loop_1 = function (y) {
              var length_1 = 0;
              var lastBit = false;
              var scans = [0, 0, 0, 0, 0];
              var _loop_2 = function (x) {
                var v = matrix.get(x, y);
                if (v === lastBit) {
                  length_1++;
                } else {
                  scans = [scans[1], scans[2], scans[3], scans[4], length_1];
                  length_1 = 1;
                  lastBit = v;
                  // Do the last 5 color changes ~ match the expected ratio for a finder pattern? 1:1:3:1:1 of b:w:b:w:b
                  var averageFinderPatternBlocksize = sum(scans) / 7;
                  var validFinderPattern =
                    Math.abs(scans[0] - averageFinderPatternBlocksize) <
                      averageFinderPatternBlocksize &&
                    Math.abs(scans[1] - averageFinderPatternBlocksize) <
                      averageFinderPatternBlocksize &&
                    Math.abs(scans[2] - 3 * averageFinderPatternBlocksize) <
                      3 * averageFinderPatternBlocksize &&
                    Math.abs(scans[3] - averageFinderPatternBlocksize) <
                      averageFinderPatternBlocksize &&
                    Math.abs(scans[4] - averageFinderPatternBlocksize) <
                      averageFinderPatternBlocksize &&
                    !v; // And make sure the current pixel is white since finder patterns are bordered in white
                  // Do the last 3 color changes ~ match the expected ratio for an alignment pattern? 1:1:1 of w:b:w
                  var averageAlignmentPatternBlocksize = sum(scans.slice(-3)) / 3;
                  var validAlignmentPattern =
                    Math.abs(scans[2] - averageAlignmentPatternBlocksize) <
                      averageAlignmentPatternBlocksize &&
                    Math.abs(scans[3] - averageAlignmentPatternBlocksize) <
                      averageAlignmentPatternBlocksize &&
                    Math.abs(scans[4] - averageAlignmentPatternBlocksize) <
                      averageAlignmentPatternBlocksize &&
                    v; // Is the current pixel black since alignment patterns are bordered in black
                  if (validFinderPattern) {
                    // Compute the start and end x values of the large center black square
                    var endX_1 = x - scans[3] - scans[4];
                    var startX_1 = endX_1 - scans[2];
                    var line = { startX: startX_1, endX: endX_1, y: y };
                    // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
                    // that line as the starting point.
                    var matchingQuads = activeFinderPatternQuads.filter(function (
                      q
                    ) {
                      return (
                        (startX_1 >= q.bottom.startX &&
                          startX_1 <= q.bottom.endX) ||
                        (endX_1 >= q.bottom.startX &&
                          startX_1 <= q.bottom.endX) ||
                        (startX_1 <= q.bottom.startX &&
                          endX_1 >= q.bottom.endX &&
                          scans[2] / (q.bottom.endX - q.bottom.startX) <
                            MAX_QUAD_RATIO &&
                          scans[2] / (q.bottom.endX - q.bottom.startX) >
                            MIN_QUAD_RATIO)
                      );
                    });
                    if (matchingQuads.length > 0) {
                      matchingQuads[0].bottom = line;
                    } else {
                      activeFinderPatternQuads.push({ top: line, bottom: line });
                    }
                  }
                  if (validAlignmentPattern) {
                    // Compute the start and end x values of the center black square
                    var endX_2 = x - scans[4];
                    var startX_2 = endX_2 - scans[3];
                    var line = { startX: startX_2, y: y, endX: endX_2 };
                    // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
                    // that line as the starting point.
                    var matchingQuads = activeAlignmentPatternQuads.filter(
                      function (q) {
                        return (
                          (startX_2 >= q.bottom.startX &&
                            startX_2 <= q.bottom.endX) ||
                          (endX_2 >= q.bottom.startX &&
                            startX_2 <= q.bottom.endX) ||
                          (startX_2 <= q.bottom.startX &&
                            endX_2 >= q.bottom.endX &&
                            scans[2] / (q.bottom.endX - q.bottom.startX) <
                              MAX_QUAD_RATIO &&
                            scans[2] / (q.bottom.endX - q.bottom.startX) >
                              MIN_QUAD_RATIO)
                        );
                      }
                    );
                    if (matchingQuads.length > 0) {
                      matchingQuads[0].bottom = line;
                    } else {
                      activeAlignmentPatternQuads.push({
                        top: line,
                        bottom: line,
                      });
                    }
                  }
                }
              };
              for (var x = -1; x <= matrix.width; x++) {
                _loop_2(x);
              }
              finderPatternQuads.push.apply(
                finderPatternQuads,
                activeFinderPatternQuads.filter(function (q) {
                  return q.bottom.y !== y && q.bottom.y - q.top.y >= 2;
                })
              );
              activeFinderPatternQuads = activeFinderPatternQuads.filter(
                function (q) {
                  return q.bottom.y === y;
                }
              );
              alignmentPatternQuads.push.apply(
                alignmentPatternQuads,
                activeAlignmentPatternQuads.filter(function (q) {
                  return q.bottom.y !== y;
                })
              );
              activeAlignmentPatternQuads = activeAlignmentPatternQuads.filter(
                function (q) {
                  return q.bottom.y === y;
                }
              );
            };
            for (var y = 0; y <= matrix.height; y++) {
              _loop_1(y);
            }
            finderPatternQuads.push.apply(
              finderPatternQuads,
              activeFinderPatternQuads.filter(function (q) {
                return q.bottom.y - q.top.y >= 2;
              })
            );
            alignmentPatternQuads.push.apply(
              alignmentPatternQuads,
              activeAlignmentPatternQuads
            );
            var finderPatternGroups = finderPatternQuads
              .filter(function (q) {
                return q.bottom.y - q.top.y >= 2;
              }) // All quads must be at least 2px tall since the center square is larger than a block
              .map(function (q) {
                var x =
                  (q.top.startX + q.top.endX + q.bottom.startX + q.bottom.endX) /
                  4;
                var y = (q.top.y + q.bottom.y + 1) / 2;
                if (!matrix.get(Math.round(x), Math.round(y))) {
                  return;
                }
                var lengths = [
                  q.top.endX - q.top.startX,
                  q.bottom.endX - q.bottom.startX,
                  q.bottom.y - q.top.y + 1,
                ];
                var size = sum(lengths) / lengths.length;
                var score = scorePattern(
                  { x: Math.round(x), y: Math.round(y) },
                  [1, 1, 3, 1, 1],
                  matrix
                );
                return { score: score, x: x, y: y, size: size };
              })
              .filter(function (q) {
                return !!q;
              }) // Filter out any rejected quads from above
              .sort(function (a, b) {
                return a.score - b.score;
              })
              // Now take the top finder pattern options and try to find 2 other options with a similar size.
              .map(function (point, i, finderPatterns) {
                if (i > MAX_FINDERPATTERNS_TO_SEARCH) {
                  return null;
                }
                var otherPoints = finderPatterns
                  .filter(function (p, ii) {
                    return i !== ii;
                  })
                  .map(function (p) {
                    return {
                      x: p.x,
                      y: p.y,
                      score:
                        p.score + Math.pow(p.size - point.size, 2) / point.size,
                      size: p.size,
                    };
                  })
                  .sort(function (a, b) {
                    return a.score - b.score;
                  });
                if (otherPoints.length < 2) {
                  return null;
                }
                var score =
                  point.score + otherPoints[0].score + otherPoints[1].score;
                return {
                  points: [point].concat(otherPoints.slice(0, 2)),
                  score: score,
                };
              })
              .filter(function (q) {
                return !!q;
              }) // Filter out any rejected finder patterns from above
              .sort(function (a, b) {
                return a.score - b.score;
              });
            if (finderPatternGroups.length === 0) {
              return null;
            }
            var _a = reorderFinderPatterns(
                finderPatternGroups[0].points[0],
                finderPatternGroups[0].points[1],
                finderPatternGroups[0].points[2]
              ),
              topRight = _a.topRight,
              topLeft = _a.topLeft,
              bottomLeft = _a.bottomLeft;
            var alignment = findAlignmentPattern(
              matrix,
              alignmentPatternQuads,
              topRight,
              topLeft,
              bottomLeft
            );
            var result = [];
            if (alignment) {
              result.push({
                alignmentPattern: {
                  x: alignment.alignmentPattern.x,
                  y: alignment.alignmentPattern.y,
                },
                bottomLeft: { x: bottomLeft.x, y: bottomLeft.y },
                dimension: alignment.dimension,
                topLeft: { x: topLeft.x, y: topLeft.y },
                topRight: { x: topRight.x, y: topRight.y },
              });
            }
            // We normally use the center of the quads as the location of the tracking points, which is optimal for most cases and will account
            // for a skew in the image. However, In some cases, a slight skew might not be real and instead be caused by image compression
            // errors and/or low resolution. For those cases, we'd be better off centering the point exactly in the middle of the black area. We
            // compute and return the location data for the naively centered points as it is little additional work and allows for multiple
            // attempts at decoding harder images.
            var midTopRight = recenterLocation(matrix, topRight);
            var midTopLeft = recenterLocation(matrix, topLeft);
            var midBottomLeft = recenterLocation(matrix, bottomLeft);
            var centeredAlignment = findAlignmentPattern(
              matrix,
              alignmentPatternQuads,
              midTopRight,
              midTopLeft,
              midBottomLeft
            );
            if (centeredAlignment) {
              result.push({
                alignmentPattern: {
                  x: centeredAlignment.alignmentPattern.x,
                  y: centeredAlignment.alignmentPattern.y,
                },
                bottomLeft: { x: midBottomLeft.x, y: midBottomLeft.y },
                topLeft: { x: midTopLeft.x, y: midTopLeft.y },
                topRight: { x: midTopRight.x, y: midTopRight.y },
                dimension: centeredAlignment.dimension,
              });
            }
            if (result.length === 0) {
              return null;
            }
            return result;
          }
          exports.locate = locate;
          function findAlignmentPattern(
            matrix,
            alignmentPatternQuads,
            topRight,
            topLeft,
            bottomLeft
          ) {
            var _a;
            // Now that we've found the three finder patterns we can determine the blockSize and the size of the QR code.
            // We'll use these to help find the alignment pattern but also later when we do the extraction.
            var dimension;
            var moduleSize;
            try {
              (_a = computeDimension(topLeft, topRight, bottomLeft, matrix)),
                (dimension = _a.dimension),
                (moduleSize = _a.moduleSize);
            } catch (e) {
              return null;
            }
            // Now find the alignment pattern
            var bottomRightFinderPattern = {
              x: topRight.x - topLeft.x + bottomLeft.x,
              y: topRight.y - topLeft.y + bottomLeft.y,
            };
            var modulesBetweenFinderPatterns =
              (distance(topLeft, bottomLeft) + distance(topLeft, topRight)) /
              2 /
              moduleSize;
            var correctionToTopLeft = 1 - 3 / modulesBetweenFinderPatterns;
            var expectedAlignmentPattern = {
              x:
                topLeft.x +
                correctionToTopLeft * (bottomRightFinderPattern.x - topLeft.x),
              y:
                topLeft.y +
                correctionToTopLeft * (bottomRightFinderPattern.y - topLeft.y),
            };
            var alignmentPatterns = alignmentPatternQuads
              .map(function (q) {
                var x =
                  (q.top.startX + q.top.endX + q.bottom.startX + q.bottom.endX) /
                  4;
                var y = (q.top.y + q.bottom.y + 1) / 2;
                if (!matrix.get(Math.floor(x), Math.floor(y))) {
                  return;
                }
                var sizeScore = scorePattern(
                  { x: Math.floor(x), y: Math.floor(y) },
                  [1, 1, 1],
                  matrix
                );
                var score =
                  sizeScore + distance({ x: x, y: y }, expectedAlignmentPattern);
                return { x: x, y: y, score: score };
              })
              .filter(function (v) {
                return !!v;
              })
              .sort(function (a, b) {
                return a.score - b.score;
              });
            // If there are less than 15 modules between finder patterns it's a version 1 QR code and as such has no alignmemnt pattern
            // so we can only use our best guess.
            var alignmentPattern =
              modulesBetweenFinderPatterns >= 15 && alignmentPatterns.length
                ? alignmentPatterns[0]
                : expectedAlignmentPattern;
            return { alignmentPattern: alignmentPattern, dimension: dimension };
          }
  
          /***/
        },
        /******/
      ]
    )["default"];
  });