js/source/legacy/jsqr.js

   1 (function webpackUniversalModuleDefinition(root, factory) {
   2         if(typeof exports === 'object' && typeof module === 'object')
   3                 module.exports = factory();
   4         else if(typeof define === 'function' && define.amd)
   5                 define([], factory);
   6         else if(typeof exports === 'object')
   7                 exports["jsQR"] = factory();
   8         else
   9                 root["jsQR"] = factory();
  10 })(typeof self !== 'undefined' ? self : this, function() {
  11 return /******/ (function(modules) { // webpackBootstrap
  12 /******/        // The module cache
  13 /******/        var installedModules = {};
  14 /******/
  15 /******/        // The require function
  16 /******/        function __webpack_require__(moduleId) {
  17 /******/
  18 /******/                // Check if module is in cache
  19 /******/                if(installedModules[moduleId]) {
  20 /******/                        return installedModules[moduleId].exports;
  21 /******/                }
  22 /******/                // Create a new module (and put it into the cache)
  23 /******/                var module = installedModules[moduleId] = {
  24 /******/                        i: moduleId,
  25 /******/                        l: false,
  26 /******/                        exports: {}
  27 /******/                };
  28 /******/
  29 /******/                // Execute the module function
  30 /******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  31 /******/
  32 /******/                // Flag the module as loaded
  33 /******/                module.l = true;
  34 /******/
  35 /******/                // Return the exports of the module
  36 /******/                return module.exports;
  37 /******/        }
  38 /******/
  39 /******/
  40 /******/        // expose the modules object (__webpack_modules__)
  41 /******/        __webpack_require__.m = modules;
  42 /******/
  43 /******/        // expose the module cache
  44 /******/        __webpack_require__.c = installedModules;
  45 /******/
  46 /******/        // define getter function for harmony exports
  47 /******/        __webpack_require__.d = function(exports, name, getter) {
  48 /******/                if(!__webpack_require__.o(exports, name)) {
  49 /******/                        Object.defineProperty(exports, name, {
  50 /******/                                configurable: false,
  51 /******/                                enumerable: true,
  52 /******/                                get: getter
  53 /******/                        });
  54 /******/                }
  55 /******/        };
  56 /******/
  57 /******/        // getDefaultExport function for compatibility with non-harmony modules
  58 /******/        __webpack_require__.n = function(module) {
  59 /******/                var getter = module && module.__esModule ?
  60 /******/                        function getDefault() { return module['default']; } :
  61 /******/                        function getModuleExports() { return module; };
  62 /******/                __webpack_require__.d(getter, 'a', getter);
  63 /******/                return getter;
  64 /******/        };
  65 /******/
  66 /******/        // Object.prototype.hasOwnProperty.call
  67 /******/        __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  68 /******/
  69 /******/        // __webpack_public_path__
  70 /******/        __webpack_require__.p = "";
  71 /******/
  72 /******/        // Load entry module and return exports
  73 /******/        return __webpack_require__(__webpack_require__.s = 3);
  74 /******/ })
  75 /************************************************************************/
  76 /******/ ([
  77 /* 0 */
  78 /***/ (function(module, exports, __webpack_require__) {
  79
  80 "use strict";
  81
  82 Object.defineProperty(exports, "__esModule", { value: true });
  83 var BitMatrix = /** @class */ (function () {
  84     function BitMatrix(data, width) {
  85         this.width = width;
  86         this.height = data.length / width;
  87         this.data = data;
  88     }
  89     BitMatrix.createEmpty = function (width, height) {
  90         return new BitMatrix(new Uint8ClampedArray(width * height), width);
  91     };
  92     BitMatrix.prototype.get = function (x, y) {
  93         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
  94             return false;
  95         }
  96         return !!this.data[y * this.width + x];
  97     };
  98     BitMatrix.prototype.set = function (x, y, v) {
  99         this.data[y * this.width + x] = v ? 1 : 0;
 100     };
 101     BitMatrix.prototype.setRegion = function (left, top, width, height, v) {
 102         for (var y = top; y < top + height; y++) {
 103             for (var x = left; x < left + width; x++) {
 104                 this.set(x, y, !!v);
 105             }
 106         }
 107     };
 108     return BitMatrix;
 109 }());
 110 exports.BitMatrix = BitMatrix;
 111
 112
 113 /***/ }),
 114 /* 1 */
 115 /***/ (function(module, exports, __webpack_require__) {
 116
 117 "use strict";
 118
 119 Object.defineProperty(exports, "__esModule", { value: true });
 120 var GenericGFPoly_1 = __webpack_require__(2);
 121 function addOrSubtractGF(a, b) {
 122     return a ^ b; // tslint:disable-line:no-bitwise
 123 }
 124 exports.addOrSubtractGF = addOrSubtractGF;
 125 var GenericGF = /** @class */ (function () {
 126     function GenericGF(primitive, size, genBase) {
 127         this.primitive = primitive;
 128         this.size = size;
 129         this.generatorBase = genBase;
 130         this.expTable = new Array(this.size);
 131         this.logTable = new Array(this.size);
 132         var x = 1;
 133         for (var i = 0; i < this.size; i++) {
 134             this.expTable[i] = x;
 135             x = x * 2;
 136             if (x >= this.size) {
 137                 x = (x ^ this.primitive) & (this.size - 1); // tslint:disable-line:no-bitwise
 138             }
 139         }
 140         for (var i = 0; i < this.size - 1; i++) {
 141             this.logTable[this.expTable[i]] = i;
 142         }
 143         this.zero = new GenericGFPoly_1.default(this, Uint8ClampedArray.from([0]));
 144         this.one = new GenericGFPoly_1.default(this, Uint8ClampedArray.from([1]));
 145     }
 146     GenericGF.prototype.multiply = function (a, b) {
 147         if (a === 0 || b === 0) {
 148             return 0;
 149         }
 150         return this.expTable[(this.logTable[a] + this.logTable[b]) % (this.size - 1)];
 151     };
 152     GenericGF.prototype.inverse = function (a) {
 153         if (a === 0) {
 154             throw new Error("Can't invert 0");
 155         }
 156         return this.expTable[this.size - this.logTable[a] - 1];
 157     };
 158     GenericGF.prototype.buildMonomial = function (degree, coefficient) {
 159         if (degree < 0) {
 160             throw new Error("Invalid monomial degree less than 0");
 161         }
 162         if (coefficient === 0) {
 163             return this.zero;
 164         }
 165         var coefficients = new Uint8ClampedArray(degree + 1);
 166         coefficients[0] = coefficient;
 167         return new GenericGFPoly_1.default(this, coefficients);
 168     };
 169     GenericGF.prototype.log = function (a) {
 170         if (a === 0) {
 171             throw new Error("Can't take log(0)");
 172         }
 173         return this.logTable[a];
 174     };
 175     GenericGF.prototype.exp = function (a) {
 176         return this.expTable[a];
 177     };
 178     return GenericGF;
 179 }());
 180 exports.default = GenericGF;
 181
 182
 183 /***/ }),
 184 /* 2 */
 185 /***/ (function(module, exports, __webpack_require__) {
 186
 187 "use strict";
 188
 189 Object.defineProperty(exports, "__esModule", { value: true });
 190 var GenericGF_1 = __webpack_require__(1);
 191 var GenericGFPoly = /** @class */ (function () {
 192     function GenericGFPoly(field, coefficients) {
 193         if (coefficients.length === 0) {
 194             throw new Error("No coefficients.");
 195         }
 196         this.field = field;
 197         var coefficientsLength = coefficients.length;
 198         if (coefficientsLength > 1 && coefficients[0] === 0) {
 199             // Leading term must be non-zero for anything except the constant polynomial "0"
 200             var firstNonZero = 1;
 201             while (firstNonZero < coefficientsLength && coefficients[firstNonZero] === 0) {
 202                 firstNonZero++;
 203             }
 204             if (firstNonZero === coefficientsLength) {
 205                 this.coefficients = field.zero.coefficients;
 206             }
 207             else {
 208                 this.coefficients = new Uint8ClampedArray(coefficientsLength - firstNonZero);
 209                 for (var i = 0; i < this.coefficients.length; i++) {
 210                     this.coefficients[i] = coefficients[firstNonZero + i];
 211                 }
 212             }
 213         }
 214         else {
 215             this.coefficients = coefficients;
 216         }
 217     }
 218     GenericGFPoly.prototype.degree = function () {
 219         return this.coefficients.length - 1;
 220     };
 221     GenericGFPoly.prototype.isZero = function () {
 222         return this.coefficients[0] === 0;
 223     };
 224     GenericGFPoly.prototype.getCoefficient = function (degree) {
 225         return this.coefficients[this.coefficients.length - 1 - degree];
 226     };
 227     GenericGFPoly.prototype.addOrSubtract = function (other) {
 228         var _a;
 229         if (this.isZero()) {
 230             return other;
 231         }
 232         if (other.isZero()) {
 233             return this;
 234         }
 235         var smallerCoefficients = this.coefficients;
 236         var largerCoefficients = other.coefficients;
 237         if (smallerCoefficients.length > largerCoefficients.length) {
 238             _a = [largerCoefficients, smallerCoefficients], smallerCoefficients = _a[0], largerCoefficients = _a[1];
 239         }
 240         var sumDiff = new Uint8ClampedArray(largerCoefficients.length);
 241         var lengthDiff = largerCoefficients.length - smallerCoefficients.length;
 242         for (var i = 0; i < lengthDiff; i++) {
 243             sumDiff[i] = largerCoefficients[i];
 244         }
 245         for (var i = lengthDiff; i < largerCoefficients.length; i++) {
 246             sumDiff[i] = GenericGF_1.addOrSubtractGF(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
 247         }
 248         return new GenericGFPoly(this.field, sumDiff);
 249     };
 250     GenericGFPoly.prototype.multiply = function (scalar) {
 251         if (scalar === 0) {
 252             return this.field.zero;
 253         }
 254         if (scalar === 1) {
 255             return this;
 256         }
 257         var size = this.coefficients.length;
 258         var product = new Uint8ClampedArray(size);
 259         for (var i = 0; i < size; i++) {
 260             product[i] = this.field.multiply(this.coefficients[i], scalar);
 261         }
 262         return new GenericGFPoly(this.field, product);
 263     };
 264     GenericGFPoly.prototype.multiplyPoly = function (other) {
 265         if (this.isZero() || other.isZero()) {
 266             return this.field.zero;
 267         }
 268         var aCoefficients = this.coefficients;
 269         var aLength = aCoefficients.length;
 270         var bCoefficients = other.coefficients;
 271         var bLength = bCoefficients.length;
 272         var product = new Uint8ClampedArray(aLength + bLength - 1);
 273         for (var i = 0; i < aLength; i++) {
 274             var aCoeff = aCoefficients[i];
 275             for (var j = 0; j < bLength; j++) {
 276                 product[i + j] = GenericGF_1.addOrSubtractGF(product[i + j], this.field.multiply(aCoeff, bCoefficients[j]));
 277             }
 278         }
 279         return new GenericGFPoly(this.field, product);
 280     };
 281     GenericGFPoly.prototype.multiplyByMonomial = function (degree, coefficient) {
 282         if (degree < 0) {
 283             throw new Error("Invalid degree less than 0");
 284         }
 285         if (coefficient === 0) {
 286             return this.field.zero;
 287         }
 288         var size = this.coefficients.length;
 289         var product = new Uint8ClampedArray(size + degree);
 290         for (var i = 0; i < size; i++) {
 291             product[i] = this.field.multiply(this.coefficients[i], coefficient);
 292         }
 293         return new GenericGFPoly(this.field, product);
 294     };
 295     GenericGFPoly.prototype.evaluateAt = function (a) {
 296         var result = 0;
 297         if (a === 0) {
 298             // Just return the x^0 coefficient
 299             return this.getCoefficient(0);
 300         }
 301         var size = this.coefficients.length;
 302         if (a === 1) {
 303             // Just the sum of the coefficients
 304             this.coefficients.forEach(function (coefficient) {
 305                 result = GenericGF_1.addOrSubtractGF(result, coefficient);
 306             });
 307             return result;
 308         }
 309         result = this.coefficients[0];
 310         for (var i = 1; i < size; i++) {
 311             result = GenericGF_1.addOrSubtractGF(this.field.multiply(a, result), this.coefficients[i]);
 312         }
 313         return result;
 314     };
 315     return GenericGFPoly;
 316 }());
 317 exports.default = GenericGFPoly;
 318
 319
 320 /***/ }),
 321 /* 3 */
 322 /***/ (function(module, exports, __webpack_require__) {
 323
 324 "use strict";
 325
 326 Object.defineProperty(exports, "__esModule", { value: true });
 327 var binarizer_1 = __webpack_require__(4);
 328 var decoder_1 = __webpack_require__(5);
 329 var extractor_1 = __webpack_require__(11);
 330 var locator_1 = __webpack_require__(12);
 331 function scan(matrix) {
 332     var locations = locator_1.locate(matrix);
 333     if (!locations) {
 334         return null;
 335     }
 336     for (var _i = 0, locations_1 = locations; _i < locations_1.length; _i++) {
 337         var location_1 = locations_1[_i];
 338         var extracted = extractor_1.extract(matrix, location_1);
 339         var decoded = decoder_1.decode(extracted.matrix);
 340         if (decoded) {
 341             return {
 342                 binaryData: decoded.bytes,
 343                 data: decoded.text,
 344                 chunks: decoded.chunks,
 345                 version: decoded.version,
 346                 location: {
 347                     topRightCorner: extracted.mappingFunction(location_1.dimension, 0),
 348                     topLeftCorner: extracted.mappingFunction(0, 0),
 349                     bottomRightCorner: extracted.mappingFunction(location_1.dimension, location_1.dimension),
 350                     bottomLeftCorner: extracted.mappingFunction(0, location_1.dimension),
 351                     topRightFinderPattern: location_1.topRight,
 352                     topLeftFinderPattern: location_1.topLeft,
 353                     bottomLeftFinderPattern: location_1.bottomLeft,
 354                     bottomRightAlignmentPattern: location_1.alignmentPattern,
 355                 },
 356             };
 357         }
 358     }
 359     return null;
 360 }
 361 var defaultOptions = {
 362     inversionAttempts: "attemptBoth",
 363 };
 364 function jsQR(data, width, height, providedOptions) {
 365     if (providedOptions === void 0) { providedOptions = {}; }
 366     var options = defaultOptions;
 367     Object.keys(options || {}).forEach(function (opt) {
 368         options[opt] = providedOptions[opt] || options[opt];
 369     });
 370     var shouldInvert = options.inversionAttempts === "attemptBoth" || options.inversionAttempts === "invertFirst";
 371     var tryInvertedFirst = options.inversionAttempts === "onlyInvert" || options.inversionAttempts === "invertFirst";
 372     var _a = binarizer_1.binarize(data, width, height, shouldInvert), binarized = _a.binarized, inverted = _a.inverted;
 373     var result = scan(tryInvertedFirst ? inverted : binarized);
 374     if (!result && (options.inversionAttempts === "attemptBoth" || options.inversionAttempts === "invertFirst")) {
 375         result = scan(tryInvertedFirst ? binarized : inverted);
 376     }
 377     return result;
 378 }
 379 jsQR.default = jsQR;
 380 exports.default = jsQR;
 381
 382
 383 /***/ }),
 384 /* 4 */
 385 /***/ (function(module, exports, __webpack_require__) {
 386
 387 "use strict";
 388
 389 Object.defineProperty(exports, "__esModule", { value: true });
 390 var BitMatrix_1 = __webpack_require__(0);
 391 var REGION_SIZE = 8;
 392 var MIN_DYNAMIC_RANGE = 24;
 393 function numBetween(value, min, max) {
 394     return value < min ? min : value > max ? max : value;
 395 }
 396 // Like BitMatrix but accepts arbitry Uint8 values
 397 var Matrix = /** @class */ (function () {
 398     function Matrix(width, height) {
 399         this.width = width;
 400         this.data = new Uint8ClampedArray(width * height);
 401     }
 402     Matrix.prototype.get = function (x, y) {
 403         return this.data[y * this.width + x];
 404     };
 405     Matrix.prototype.set = function (x, y, value) {
 406         this.data[y * this.width + x] = value;
 407     };
 408     return Matrix;
 409 }());
 410 function binarize(data, width, height, returnInverted) {
 411     if (data.length !== width * height * 4) {
 412         throw new Error("Malformed data passed to binarizer.");
 413     }
 414     // Convert image to greyscale
 415     var greyscalePixels = new Matrix(width, height);
 416     for (var x = 0; x < width; x++) {
 417         for (var y = 0; y < height; y++) {
 418             var r = data[((y * width + x) * 4) + 0];
 419             var g = data[((y * width + x) * 4) + 1];
 420             var b = data[((y * width + x) * 4) + 2];
 421             greyscalePixels.set(x, y, 0.2126 * r + 0.7152 * g + 0.0722 * b);
 422         }
 423     }
 424     var horizontalRegionCount = Math.ceil(width / REGION_SIZE);
 425     var verticalRegionCount = Math.ceil(height / REGION_SIZE);
 426     var blackPoints = new Matrix(horizontalRegionCount, verticalRegionCount);
 427     for (var verticalRegion = 0; verticalRegion < verticalRegionCount; verticalRegion++) {
 428         for (var hortizontalRegion = 0; hortizontalRegion < horizontalRegionCount; hortizontalRegion++) {
 429             var sum = 0;
 430             var min = Infinity;
 431             var max = 0;
 432             for (var y = 0; y < REGION_SIZE; y++) {
 433                 for (var x = 0; x < REGION_SIZE; x++) {
 434                     var pixelLumosity = greyscalePixels.get(hortizontalRegion * REGION_SIZE + x, verticalRegion * REGION_SIZE + y);
 435                     sum += pixelLumosity;
 436                     min = Math.min(min, pixelLumosity);
 437                     max = Math.max(max, pixelLumosity);
 438                 }
 439             }
 440             var average = sum / (Math.pow(REGION_SIZE, 2));
 441             if (max - min <= MIN_DYNAMIC_RANGE) {
 442                 // If variation within the block is low, assume this is a block with only light or only
 443                 // dark pixels. In that case we do not want to use the average, as it would divide this
 444                 // low contrast area into black and white pixels, essentially creating data out of noise.
 445                 //
 446                 // Default the blackpoint for these blocks to be half the min - effectively white them out
 447                 average = min / 2;
 448                 if (verticalRegion > 0 && hortizontalRegion > 0) {
 449                     // Correct the "white background" assumption for blocks that have neighbors by comparing
 450                     // the pixels in this block to the previously calculated black points. This is based on
 451                     // the fact that dark barcode symbology is always surrounded by some amount of light
 452                     // background for which reasonable black point estimates were made. The bp estimated at
 453                     // the boundaries is used for the interior.
 454                     // The (min < bp) is arbitrary but works better than other heuristics that were tried.
 455                     var averageNeighborBlackPoint = (blackPoints.get(hortizontalRegion, verticalRegion - 1) +
 456                         (2 * blackPoints.get(hortizontalRegion - 1, verticalRegion)) +
 457                         blackPoints.get(hortizontalRegion - 1, verticalRegion - 1)) / 4;
 458                     if (min < averageNeighborBlackPoint) {
 459                         average = averageNeighborBlackPoint;
 460                     }
 461                 }
 462             }
 463             blackPoints.set(hortizontalRegion, verticalRegion, average);
 464         }
 465     }
 466     var binarized = BitMatrix_1.BitMatrix.createEmpty(width, height);
 467     var inverted = null;
 468     if (returnInverted) {
 469         inverted = BitMatrix_1.BitMatrix.createEmpty(width, height);
 470     }
 471     for (var verticalRegion = 0; verticalRegion < verticalRegionCount; verticalRegion++) {
 472         for (var hortizontalRegion = 0; hortizontalRegion < horizontalRegionCount; hortizontalRegion++) {
 473             var left = numBetween(hortizontalRegion, 2, horizontalRegionCount - 3);
 474             var top_1 = numBetween(verticalRegion, 2, verticalRegionCount - 3);
 475             var sum = 0;
 476             for (var xRegion = -2; xRegion <= 2; xRegion++) {
 477                 for (var yRegion = -2; yRegion <= 2; yRegion++) {
 478                     sum += blackPoints.get(left + xRegion, top_1 + yRegion);
 479                 }
 480             }
 481             var threshold = sum / 25;
 482             for (var xRegion = 0; xRegion < REGION_SIZE; xRegion++) {
 483                 for (var yRegion = 0; yRegion < REGION_SIZE; yRegion++) {
 484                     var x = hortizontalRegion * REGION_SIZE + xRegion;
 485                     var y = verticalRegion * REGION_SIZE + yRegion;
 486                     var lum = greyscalePixels.get(x, y);
 487                     binarized.set(x, y, lum <= threshold);
 488                     if (returnInverted) {
 489                         inverted.set(x, y, !(lum <= threshold));
 490                     }
 491                 }
 492             }
 493         }
 494     }
 495     if (returnInverted) {
 496         return { binarized: binarized, inverted: inverted };
 497     }
 498     return { binarized: binarized };
 499 }
 500 exports.binarize = binarize;
 501
 502
 503 /***/ }),
 504 /* 5 */
 505 /***/ (function(module, exports, __webpack_require__) {
 506
 507 "use strict";
 508
 509 Object.defineProperty(exports, "__esModule", { value: true });
 510 var BitMatrix_1 = __webpack_require__(0);
 511 var decodeData_1 = __webpack_require__(6);
 512 var reedsolomon_1 = __webpack_require__(9);
 513 var version_1 = __webpack_require__(10);
 514 // tslint:disable:no-bitwise
 515 function numBitsDiffering(x, y) {
 516     var z = x ^ y;
 517     var bitCount = 0;
 518     while (z) {
 519         bitCount++;
 520         z &= z - 1;
 521     }
 522     return bitCount;
 523 }
 524 function pushBit(bit, byte) {
 525     return (byte << 1) | bit;
 526 }
 527 // tslint:enable:no-bitwise
 528 var FORMAT_INFO_TABLE = [
 529     { bits: 0x5412, formatInfo: { errorCorrectionLevel: 1, dataMask: 0 } },
 530     { bits: 0x5125, formatInfo: { errorCorrectionLevel: 1, dataMask: 1 } },
 531     { bits: 0x5E7C, formatInfo: { errorCorrectionLevel: 1, dataMask: 2 } },
 532     { bits: 0x5B4B, formatInfo: { errorCorrectionLevel: 1, dataMask: 3 } },
 533     { bits: 0x45F9, formatInfo: { errorCorrectionLevel: 1, dataMask: 4 } },
 534     { bits: 0x40CE, formatInfo: { errorCorrectionLevel: 1, dataMask: 5 } },
 535     { bits: 0x4F97, formatInfo: { errorCorrectionLevel: 1, dataMask: 6 } },
 536     { bits: 0x4AA0, formatInfo: { errorCorrectionLevel: 1, dataMask: 7 } },
 537     { bits: 0x77C4, formatInfo: { errorCorrectionLevel: 0, dataMask: 0 } },
 538     { bits: 0x72F3, formatInfo: { errorCorrectionLevel: 0, dataMask: 1 } },
 539     { bits: 0x7DAA, formatInfo: { errorCorrectionLevel: 0, dataMask: 2 } },
 540     { bits: 0x789D, formatInfo: { errorCorrectionLevel: 0, dataMask: 3 } },
 541     { bits: 0x662F, formatInfo: { errorCorrectionLevel: 0, dataMask: 4 } },
 542     { bits: 0x6318, formatInfo: { errorCorrectionLevel: 0, dataMask: 5 } },
 543     { bits: 0x6C41, formatInfo: { errorCorrectionLevel: 0, dataMask: 6 } },
 544     { bits: 0x6976, formatInfo: { errorCorrectionLevel: 0, dataMask: 7 } },
 545     { bits: 0x1689, formatInfo: { errorCorrectionLevel: 3, dataMask: 0 } },
 546     { bits: 0x13BE, formatInfo: { errorCorrectionLevel: 3, dataMask: 1 } },
 547     { bits: 0x1CE7, formatInfo: { errorCorrectionLevel: 3, dataMask: 2 } },
 548     { bits: 0x19D0, formatInfo: { errorCorrectionLevel: 3, dataMask: 3 } },
 549     { bits: 0x0762, formatInfo: { errorCorrectionLevel: 3, dataMask: 4 } },
 550     { bits: 0x0255, formatInfo: { errorCorrectionLevel: 3, dataMask: 5 } },
 551     { bits: 0x0D0C, formatInfo: { errorCorrectionLevel: 3, dataMask: 6 } },
 552     { bits: 0x083B, formatInfo: { errorCorrectionLevel: 3, dataMask: 7 } },
 553     { bits: 0x355F, formatInfo: { errorCorrectionLevel: 2, dataMask: 0 } },
 554     { bits: 0x3068, formatInfo: { errorCorrectionLevel: 2, dataMask: 1 } },
 555     { bits: 0x3F31, formatInfo: { errorCorrectionLevel: 2, dataMask: 2 } },
 556     { bits: 0x3A06, formatInfo: { errorCorrectionLevel: 2, dataMask: 3 } },
 557     { bits: 0x24B4, formatInfo: { errorCorrectionLevel: 2, dataMask: 4 } },
 558     { bits: 0x2183, formatInfo: { errorCorrectionLevel: 2, dataMask: 5 } },
 559     { bits: 0x2EDA, formatInfo: { errorCorrectionLevel: 2, dataMask: 6 } },
 560     { bits: 0x2BED, formatInfo: { errorCorrectionLevel: 2, dataMask: 7 } },
 561 ];
 562 var DATA_MASKS = [
 563     function (p) { return ((p.y + p.x) % 2) === 0; },
 564     function (p) { return (p.y % 2) === 0; },
 565     function (p) { return p.x % 3 === 0; },
 566     function (p) { return (p.y + p.x) % 3 === 0; },
 567     function (p) { return (Math.floor(p.y / 2) + Math.floor(p.x / 3)) % 2 === 0; },
 568     function (p) { return ((p.x * p.y) % 2) + ((p.x * p.y) % 3) === 0; },
 569     function (p) { return ((((p.y * p.x) % 2) + (p.y * p.x) % 3) % 2) === 0; },
 570     function (p) { return ((((p.y + p.x) % 2) + (p.y * p.x) % 3) % 2) === 0; },
 571 ];
 572 function buildFunctionPatternMask(version) {
 573     var dimension = 17 + 4 * version.versionNumber;
 574     var matrix = BitMatrix_1.BitMatrix.createEmpty(dimension, dimension);
 575     matrix.setRegion(0, 0, 9, 9, true); // Top left finder pattern + separator + format
 576     matrix.setRegion(dimension - 8, 0, 8, 9, true); // Top right finder pattern + separator + format
 577     matrix.setRegion(0, dimension - 8, 9, 8, true); // Bottom left finder pattern + separator + format
 578     // Alignment patterns
 579     for (var _i = 0, _a = version.alignmentPatternCenters; _i < _a.length; _i++) {
 580         var x = _a[_i];
 581         for (var _b = 0, _c = version.alignmentPatternCenters; _b < _c.length; _b++) {
 582             var y = _c[_b];
 583             if (!(x === 6 && y === 6 || x === 6 && y === dimension - 7 || x === dimension - 7 && y === 6)) {
 584                 matrix.setRegion(x - 2, y - 2, 5, 5, true);
 585             }
 586         }
 587     }
 588     matrix.setRegion(6, 9, 1, dimension - 17, true); // Vertical timing pattern
 589     matrix.setRegion(9, 6, dimension - 17, 1, true); // Horizontal timing pattern
 590     if (version.versionNumber > 6) {
 591         matrix.setRegion(dimension - 11, 0, 3, 6, true); // Version info, top right
 592         matrix.setRegion(0, dimension - 11, 6, 3, true); // Version info, bottom left
 593     }
 594     return matrix;
 595 }
 596 function readCodewords(matrix, version, formatInfo) {
 597     var dataMask = DATA_MASKS[formatInfo.dataMask];
 598     var dimension = matrix.height;
 599     var functionPatternMask = buildFunctionPatternMask(version);
 600     var codewords = [];
 601     var currentByte = 0;
 602     var bitsRead = 0;
 603     // Read columns in pairs, from right to left
 604     var readingUp = true;
 605     for (var columnIndex = dimension - 1; columnIndex > 0; columnIndex -= 2) {
 606         if (columnIndex === 6) { // Skip whole column with vertical alignment pattern;
 607             columnIndex--;
 608         }
 609         for (var i = 0; i < dimension; i++) {
 610             var y = readingUp ? dimension - 1 - i : i;
 611             for (var columnOffset = 0; columnOffset < 2; columnOffset++) {
 612                 var x = columnIndex - columnOffset;
 613                 if (!functionPatternMask.get(x, y)) {
 614                     bitsRead++;
 615                     var bit = matrix.get(x, y);
 616                     if (dataMask({ y: y, x: x })) {
 617                         bit = !bit;
 618                     }
 619                     currentByte = pushBit(bit, currentByte);
 620                     if (bitsRead === 8) { // Whole bytes
 621                         codewords.push(currentByte);
 622                         bitsRead = 0;
 623                         currentByte = 0;
 624                     }
 625                 }
 626             }
 627         }
 628         readingUp = !readingUp;
 629     }
 630     return codewords;
 631 }
 632 function readVersion(matrix) {
 633     var dimension = matrix.height;
 634     var provisionalVersion = Math.floor((dimension - 17) / 4);
 635     if (provisionalVersion <= 6) { // 6 and under dont have version info in the QR code
 636         return version_1.VERSIONS[provisionalVersion - 1];
 637     }
 638     var topRightVersionBits = 0;
 639     for (var y = 5; y >= 0; y--) {
 640         for (var x = dimension - 9; x >= dimension - 11; x--) {
 641             topRightVersionBits = pushBit(matrix.get(x, y), topRightVersionBits);
 642         }
 643     }
 644     var bottomLeftVersionBits = 0;
 645     for (var x = 5; x >= 0; x--) {
 646         for (var y = dimension - 9; y >= dimension - 11; y--) {
 647             bottomLeftVersionBits = pushBit(matrix.get(x, y), bottomLeftVersionBits);
 648         }
 649     }
 650     var bestDifference = Infinity;
 651     var bestVersion;
 652     for (var _i = 0, VERSIONS_1 = version_1.VERSIONS; _i < VERSIONS_1.length; _i++) {
 653         var version = VERSIONS_1[_i];
 654         if (version.infoBits === topRightVersionBits || version.infoBits === bottomLeftVersionBits) {
 655             return version;
 656         }
 657         var difference = numBitsDiffering(topRightVersionBits, version.infoBits);
 658         if (difference < bestDifference) {
 659             bestVersion = version;
 660             bestDifference = difference;
 661         }
 662         difference = numBitsDiffering(bottomLeftVersionBits, version.infoBits);
 663         if (difference < bestDifference) {
 664             bestVersion = version;
 665             bestDifference = difference;
 666         }
 667     }
 668     // We can tolerate up to 3 bits of error since no two version info codewords will
 669     // differ in less than 8 bits.
 670     if (bestDifference <= 3) {
 671         return bestVersion;
 672     }
 673 }
 674 function readFormatInformation(matrix) {
 675     var topLeftFormatInfoBits = 0;
 676     for (var x = 0; x <= 8; x++) {
 677         if (x !== 6) { // Skip timing pattern bit
 678             topLeftFormatInfoBits = pushBit(matrix.get(x, 8), topLeftFormatInfoBits);
 679         }
 680     }
 681     for (var y = 7; y >= 0; y--) {
 682         if (y !== 6) { // Skip timing pattern bit
 683             topLeftFormatInfoBits = pushBit(matrix.get(8, y), topLeftFormatInfoBits);
 684         }
 685     }
 686     var dimension = matrix.height;
 687     var topRightBottomRightFormatInfoBits = 0;
 688     for (var y = dimension - 1; y >= dimension - 7; y--) { // bottom left
 689         topRightBottomRightFormatInfoBits = pushBit(matrix.get(8, y), topRightBottomRightFormatInfoBits);
 690     }
 691     for (var x = dimension - 8; x < dimension; x++) { // top right
 692         topRightBottomRightFormatInfoBits = pushBit(matrix.get(x, 8), topRightBottomRightFormatInfoBits);
 693     }
 694     var bestDifference = Infinity;
 695     var bestFormatInfo = null;
 696     for (var _i = 0, FORMAT_INFO_TABLE_1 = FORMAT_INFO_TABLE; _i < FORMAT_INFO_TABLE_1.length; _i++) {
 697         var _a = FORMAT_INFO_TABLE_1[_i], bits = _a.bits, formatInfo = _a.formatInfo;
 698         if (bits === topLeftFormatInfoBits || bits === topRightBottomRightFormatInfoBits) {
 699             return formatInfo;
 700         }
 701         var difference = numBitsDiffering(topLeftFormatInfoBits, bits);
 702         if (difference < bestDifference) {
 703             bestFormatInfo = formatInfo;
 704             bestDifference = difference;
 705         }
 706         if (topLeftFormatInfoBits !== topRightBottomRightFormatInfoBits) { // also try the other option
 707             difference = numBitsDiffering(topRightBottomRightFormatInfoBits, bits);
 708             if (difference < bestDifference) {
 709                 bestFormatInfo = formatInfo;
 710                 bestDifference = difference;
 711             }
 712         }
 713     }
 714     // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits differing means we found a match
 715     if (bestDifference <= 3) {
 716         return bestFormatInfo;
 717     }
 718     return null;
 719 }
 720 function getDataBlocks(codewords, version, ecLevel) {
 721     var ecInfo = version.errorCorrectionLevels[ecLevel];
 722     var dataBlocks = [];
 723     var totalCodewords = 0;
 724     ecInfo.ecBlocks.forEach(function (block) {
 725         for (var i = 0; i < block.numBlocks; i++) {
 726             dataBlocks.push({ numDataCodewords: block.dataCodewordsPerBlock, codewords: [] });
 727             totalCodewords += block.dataCodewordsPerBlock + ecInfo.ecCodewordsPerBlock;
 728         }
 729     });
 730     // In some cases the QR code will be malformed enough that we pull off more or less than we should.
 731     // If we pull off less there's nothing we can do.
 732     // If we pull off more we can safely truncate
 733     if (codewords.length < totalCodewords) {
 734         return null;
 735     }
 736     codewords = codewords.slice(0, totalCodewords);
 737     var shortBlockSize = ecInfo.ecBlocks[0].dataCodewordsPerBlock;
 738     // Pull codewords to fill the blocks up to the minimum size
 739     for (var i = 0; i < shortBlockSize; i++) {
 740         for (var _i = 0, dataBlocks_1 = dataBlocks; _i < dataBlocks_1.length; _i++) {
 741             var dataBlock = dataBlocks_1[_i];
 742             dataBlock.codewords.push(codewords.shift());
 743         }
 744     }
 745     // If there are any large blocks, pull codewords to fill the last element of those
 746     if (ecInfo.ecBlocks.length > 1) {
 747         var smallBlockCount = ecInfo.ecBlocks[0].numBlocks;
 748         var largeBlockCount = ecInfo.ecBlocks[1].numBlocks;
 749         for (var i = 0; i < largeBlockCount; i++) {
 750             dataBlocks[smallBlockCount + i].codewords.push(codewords.shift());
 751         }
 752     }
 753     // Add the rest of the codewords to the blocks. These are the error correction codewords.
 754     while (codewords.length > 0) {
 755         for (var _a = 0, dataBlocks_2 = dataBlocks; _a < dataBlocks_2.length; _a++) {
 756             var dataBlock = dataBlocks_2[_a];
 757             dataBlock.codewords.push(codewords.shift());
 758         }
 759     }
 760     return dataBlocks;
 761 }
 762 function decodeMatrix(matrix) {
 763     var version = readVersion(matrix);
 764     if (!version) {
 765         return null;
 766     }
 767     var formatInfo = readFormatInformation(matrix);
 768     if (!formatInfo) {
 769         return null;
 770     }
 771     var codewords = readCodewords(matrix, version, formatInfo);
 772     var dataBlocks = getDataBlocks(codewords, version, formatInfo.errorCorrectionLevel);
 773     if (!dataBlocks) {
 774         return null;
 775     }
 776     // Count total number of data bytes
 777     var totalBytes = dataBlocks.reduce(function (a, b) { return a + b.numDataCodewords; }, 0);
 778     var resultBytes = new Uint8ClampedArray(totalBytes);
 779     var resultIndex = 0;
 780     for (var _i = 0, dataBlocks_3 = dataBlocks; _i < dataBlocks_3.length; _i++) {
 781         var dataBlock = dataBlocks_3[_i];
 782         var correctedBytes = reedsolomon_1.decode(dataBlock.codewords, dataBlock.codewords.length - dataBlock.numDataCodewords);
 783         if (!correctedBytes) {
 784             return null;
 785         }
 786         for (var i = 0; i < dataBlock.numDataCodewords; i++) {
 787             resultBytes[resultIndex++] = correctedBytes[i];
 788         }
 789     }
 790     try {
 791         return decodeData_1.decode(resultBytes, version.versionNumber);
 792     }
 793     catch (_a) {
 794         return null;
 795     }
 796 }
 797 function decode(matrix) {
 798     if (matrix == null) {
 799         return null;
 800     }
 801     var result = decodeMatrix(matrix);
 802     if (result) {
 803         return result;
 804     }
 805     // Decoding didn't work, try mirroring the QR across the topLeft -> bottomRight line.
 806     for (var x = 0; x < matrix.width; x++) {
 807         for (var y = x + 1; y < matrix.height; y++) {
 808             if (matrix.get(x, y) !== matrix.get(y, x)) {
 809                 matrix.set(x, y, !matrix.get(x, y));
 810                 matrix.set(y, x, !matrix.get(y, x));
 811             }
 812         }
 813     }
 814     return decodeMatrix(matrix);
 815 }
 816 exports.decode = decode;
 817
 818
 819 /***/ }),
 820 /* 6 */
 821 /***/ (function(module, exports, __webpack_require__) {
 822
 823 "use strict";
 824
 825 Object.defineProperty(exports, "__esModule", { value: true });
 826 // tslint:disable:no-bitwise
 827 var BitStream_1 = __webpack_require__(7);
 828 var shiftJISTable_1 = __webpack_require__(8);
 829 var Mode;
 830 (function (Mode) {
 831     Mode["Numeric"] = "numeric";
 832     Mode["Alphanumeric"] = "alphanumeric";
 833     Mode["Byte"] = "byte";
 834     Mode["Kanji"] = "kanji";
 835     Mode["ECI"] = "eci";
 836 })(Mode = exports.Mode || (exports.Mode = {}));
 837 var ModeByte;
 838 (function (ModeByte) {
 839     ModeByte[ModeByte["Terminator"] = 0] = "Terminator";
 840     ModeByte[ModeByte["Numeric"] = 1] = "Numeric";
 841     ModeByte[ModeByte["Alphanumeric"] = 2] = "Alphanumeric";
 842     ModeByte[ModeByte["Byte"] = 4] = "Byte";
 843     ModeByte[ModeByte["Kanji"] = 8] = "Kanji";
 844     ModeByte[ModeByte["ECI"] = 7] = "ECI";
 845     // StructuredAppend = 0x3,
 846     // FNC1FirstPosition = 0x5,
 847     // FNC1SecondPosition = 0x9,
 848 })(ModeByte || (ModeByte = {}));
 849 function decodeNumeric(stream, size) {
 850     var bytes = [];
 851     var text = "";
 852     var characterCountSize = [10, 12, 14][size];
 853     var length = stream.readBits(characterCountSize);
 854     // Read digits in groups of 3
 855     while (length >= 3) {
 856         var num = stream.readBits(10);
 857         if (num >= 1000) {
 858             throw new Error("Invalid numeric value above 999");
 859         }
 860         var a = Math.floor(num / 100);
 861         var b = Math.floor(num / 10) % 10;
 862         var c = num % 10;
 863         bytes.push(48 + a, 48 + b, 48 + c);
 864         text += a.toString() + b.toString() + c.toString();
 865         length -= 3;
 866     }
 867     // If the number of digits aren't a multiple of 3, the remaining digits are special cased.
 868     if (length === 2) {
 869         var num = stream.readBits(7);
 870         if (num >= 100) {
 871             throw new Error("Invalid numeric value above 99");
 872         }
 873         var a = Math.floor(num / 10);
 874         var b = num % 10;
 875         bytes.push(48 + a, 48 + b);
 876         text += a.toString() + b.toString();
 877     }
 878     else if (length === 1) {
 879         var num = stream.readBits(4);
 880         if (num >= 10) {
 881             throw new Error("Invalid numeric value above 9");
 882         }
 883         bytes.push(48 + num);
 884         text += num.toString();
 885     }
 886     return { bytes: bytes, text: text };
 887 }
 888 var AlphanumericCharacterCodes = [
 889     "0", "1", "2", "3", "4", "5", "6", "7", "8",
 890     "9", "A", "B", "C", "D", "E", "F", "G", "H",
 891     "I", "J", "K", "L", "M", "N", "O", "P", "Q",
 892     "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
 893     " ", "$", "%", "*", "+", "-", ".", "/", ":",
 894 ];
 895 function decodeAlphanumeric(stream, size) {
 896     var bytes = [];
 897     var text = "";
 898     var characterCountSize = [9, 11, 13][size];
 899     var length = stream.readBits(characterCountSize);
 900     while (length >= 2) {
 901         var v = stream.readBits(11);
 902         var a = Math.floor(v / 45);
 903         var b = v % 45;
 904         bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0), AlphanumericCharacterCodes[b].charCodeAt(0));
 905         text += AlphanumericCharacterCodes[a] + AlphanumericCharacterCodes[b];
 906         length -= 2;
 907     }
 908     if (length === 1) {
 909         var a = stream.readBits(6);
 910         bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0));
 911         text += AlphanumericCharacterCodes[a];
 912     }
 913     return { bytes: bytes, text: text };
 914 }
 915 function decodeByte(stream, size) {
 916     var bytes = [];
 917     var text = "";
 918     var characterCountSize = [8, 16, 16][size];
 919     var length = stream.readBits(characterCountSize);
 920     for (var i = 0; i < length; i++) {
 921         var b = stream.readBits(8);
 922         bytes.push(b);
 923     }
 924     try {
 925         text += decodeURIComponent(bytes.map(function (b) { return "%" + ("0" + b.toString(16)).substr(-2); }).join(""));
 926     }
 927     catch (_a) {
 928         // failed to decode
 929     }
 930     return { bytes: bytes, text: text };
 931 }
 932 function decodeKanji(stream, size) {
 933     var bytes = [];
 934     var text = "";
 935     var characterCountSize = [8, 10, 12][size];
 936     var length = stream.readBits(characterCountSize);
 937     for (var i = 0; i < length; i++) {
 938         var k = stream.readBits(13);
 939         var c = (Math.floor(k / 0xC0) << 8) | (k % 0xC0);
 940         if (c < 0x1F00) {
 941             c += 0x8140;
 942         }
 943         else {
 944             c += 0xC140;
 945         }
 946         bytes.push(c >> 8, c & 0xFF);
 947         text += String.fromCharCode(shiftJISTable_1.shiftJISTable[c]);
 948     }
 949     return { bytes: bytes, text: text };
 950 }
 951 function decode(data, version) {
 952     var _a, _b, _c, _d;
 953     var stream = new BitStream_1.BitStream(data);
 954     // There are 3 'sizes' based on the version. 1-9 is small (0), 10-26 is medium (1) and 27-40 is large (2).
 955     var size = version <= 9 ? 0 : version <= 26 ? 1 : 2;
 956     var result = {
 957         text: "",
 958         bytes: [],
 959         chunks: [],
 960         version: version,
 961     };
 962     while (stream.available() >= 4) {
 963         var mode = stream.readBits(4);
 964         if (mode === ModeByte.Terminator) {
 965             return result;
 966         }
 967         else if (mode === ModeByte.ECI) {
 968             if (stream.readBits(1) === 0) {
 969                 result.chunks.push({
 970                     type: Mode.ECI,
 971                     assignmentNumber: stream.readBits(7),
 972                 });
 973             }
 974             else if (stream.readBits(1) === 0) {
 975                 result.chunks.push({
 976                     type: Mode.ECI,
 977                     assignmentNumber: stream.readBits(14),
 978                 });
 979             }
 980             else if (stream.readBits(1) === 0) {
 981                 result.chunks.push({
 982                     type: Mode.ECI,
 983                     assignmentNumber: stream.readBits(21),
 984                 });
 985             }
 986             else {
 987                 // ECI data seems corrupted
 988                 result.chunks.push({
 989                     type: Mode.ECI,
 990                     assignmentNumber: -1,
 991                 });
 992             }
 993         }
 994         else if (mode === ModeByte.Numeric) {
 995             var numericResult = decodeNumeric(stream, size);
 996             result.text += numericResult.text;
 997             (_a = result.bytes).push.apply(_a, numericResult.bytes);
 998             result.chunks.push({
 999                 type: Mode.Numeric,
1000                 text: numericResult.text,
1001             });
1002         }
1003         else if (mode === ModeByte.Alphanumeric) {
1004             var alphanumericResult = decodeAlphanumeric(stream, size);
1005             result.text += alphanumericResult.text;
1006             (_b = result.bytes).push.apply(_b, alphanumericResult.bytes);
1007             result.chunks.push({
1008                 type: Mode.Alphanumeric,
1009                 text: alphanumericResult.text,
1010             });
1011         }
1012         else if (mode === ModeByte.Byte) {
1013             var byteResult = decodeByte(stream, size);
1014             result.text += byteResult.text;
1015             (_c = result.bytes).push.apply(_c, byteResult.bytes);
1016             result.chunks.push({
1017                 type: Mode.Byte,
1018                 bytes: byteResult.bytes,
1019                 text: byteResult.text,
1020             });
1021         }
1022         else if (mode === ModeByte.Kanji) {
1023             var kanjiResult = decodeKanji(stream, size);
1024             result.text += kanjiResult.text;
1025             (_d = result.bytes).push.apply(_d, kanjiResult.bytes);
1026             result.chunks.push({
1027                 type: Mode.Kanji,
1028                 bytes: kanjiResult.bytes,
1029                 text: kanjiResult.text,
1030             });
1031         }
1032     }
1033     // If there is no data left, or the remaining bits are all 0, then that counts as a termination marker
1034     if (stream.available() === 0 || stream.readBits(stream.available()) === 0) {
1035         return result;
1036     }
1037 }
1038 exports.decode = decode;
1039
1040
1041 /***/ }),
1042 /* 7 */
1043 /***/ (function(module, exports, __webpack_require__) {
1044
1045 "use strict";
1046
1047 // tslint:disable:no-bitwise
1048 Object.defineProperty(exports, "__esModule", { value: true });
1049 var BitStream = /** @class */ (function () {
1050     function BitStream(bytes) {
1051         this.byteOffset = 0;
1052         this.bitOffset = 0;
1053         this.bytes = bytes;
1054     }
1055     BitStream.prototype.readBits = function (numBits) {
1056         if (numBits < 1 || numBits > 32 || numBits > this.available()) {
1057             throw new Error("Cannot read " + numBits.toString() + " bits");
1058         }
1059         var result = 0;
1060         // First, read remainder from current byte
1061         if (this.bitOffset > 0) {
1062             var bitsLeft = 8 - this.bitOffset;
1063             var toRead = numBits < bitsLeft ? numBits : bitsLeft;
1064             var bitsToNotRead = bitsLeft - toRead;
1065             var mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
1066             result = (this.bytes[this.byteOffset] & mask) >> bitsToNotRead;
1067             numBits -= toRead;
1068             this.bitOffset += toRead;
1069             if (this.bitOffset === 8) {
1070                 this.bitOffset = 0;
1071                 this.byteOffset++;
1072             }
1073         }
1074         // Next read whole bytes
1075         if (numBits > 0) {
1076             while (numBits >= 8) {
1077                 result = (result << 8) | (this.bytes[this.byteOffset] & 0xFF);
1078                 this.byteOffset++;
1079                 numBits -= 8;
1080             }
1081             // Finally read a partial byte
1082             if (numBits > 0) {
1083                 var bitsToNotRead = 8 - numBits;
1084                 var mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
1085                 result = (result << numBits) | ((this.bytes[this.byteOffset] & mask) >> bitsToNotRead);
1086                 this.bitOffset += numBits;
1087             }
1088         }
1089         return result;
1090     };
1091     BitStream.prototype.available = function () {
1092         return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
1093     };
1094     return BitStream;
1095 }());
1096 exports.BitStream = BitStream;
1097
1098
1099 /***/ }),
1100 /* 8 */
1101 /***/ (function(module, exports, __webpack_require__) {
1102
1103 "use strict";
1104
1105 Object.defineProperty(exports, "__esModule", { value: true });
1106 exports.shiftJISTable = {
1107     0x20: 0x0020,
1108     0x21: 0x0021,
1109     0x22: 0x0022,
1110     0x23: 0x0023,
1111     0x24: 0x0024,
1112     0x25: 0x0025,
1113     0x26: 0x0026,
1114     0x27: 0x0027,
1115     0x28: 0x0028,
1116     0x29: 0x0029,
1117     0x2A: 0x002A,
1118     0x2B: 0x002B,
1119     0x2C: 0x002C,
1120     0x2D: 0x002D,
1121     0x2E: 0x002E,
1122     0x2F: 0x002F,
1123     0x30: 0x0030,
1124     0x31: 0x0031,
1125     0x32: 0x0032,
1126     0x33: 0x0033,
1127     0x34: 0x0034,
1128     0x35: 0x0035,
1129     0x36: 0x0036,
1130     0x37: 0x0037,
1131     0x38: 0x0038,
1132     0x39: 0x0039,
1133     0x3A: 0x003A,
1134     0x3B: 0x003B,
1135     0x3C: 0x003C,
1136     0x3D: 0x003D,
1137     0x3E: 0x003E,
1138     0x3F: 0x003F,
1139     0x40: 0x0040,
1140     0x41: 0x0041,
1141     0x42: 0x0042,
1142     0x43: 0x0043,
1143     0x44: 0x0044,
1144     0x45: 0x0045,
1145     0x46: 0x0046,
1146     0x47: 0x0047,
1147     0x48: 0x0048,
1148     0x49: 0x0049,
1149     0x4A: 0x004A,
1150     0x4B: 0x004B,
1151     0x4C: 0x004C,
1152     0x4D: 0x004D,
1153     0x4E: 0x004E,
1154     0x4F: 0x004F,
1155     0x50: 0x0050,
1156     0x51: 0x0051,
1157     0x52: 0x0052,
1158     0x53: 0x0053,
1159     0x54: 0x0054,
1160     0x55: 0x0055,
1161     0x56: 0x0056,
1162     0x57: 0x0057,
1163     0x58: 0x0058,
1164     0x59: 0x0059,
1165     0x5A: 0x005A,
1166     0x5B: 0x005B,
1167     0x5C: 0x00A5,
1168     0x5D: 0x005D,
1169     0x5E: 0x005E,
1170     0x5F: 0x005F,
1171     0x60: 0x0060,
1172     0x61: 0x0061,
1173     0x62: 0x0062,
1174     0x63: 0x0063,
1175     0x64: 0x0064,
1176     0x65: 0x0065,
1177     0x66: 0x0066,
1178     0x67: 0x0067,
1179     0x68: 0x0068,
1180     0x69: 0x0069,
1181     0x6A: 0x006A,
1182     0x6B: 0x006B,
1183     0x6C: 0x006C,
1184     0x6D: 0x006D,
1185     0x6E: 0x006E,
1186     0x6F: 0x006F,
1187     0x70: 0x0070,
1188     0x71: 0x0071,
1189     0x72: 0x0072,
1190     0x73: 0x0073,
1191     0x74: 0x0074,
1192     0x75: 0x0075,
1193     0x76: 0x0076,
1194     0x77: 0x0077,
1195     0x78: 0x0078,
1196     0x79: 0x0079,
1197     0x7A: 0x007A,
1198     0x7B: 0x007B,
1199     0x7C: 0x007C,
1200     0x7D: 0x007D,
1201     0x7E: 0x203E,
1202     0x8140: 0x3000,
1203     0x8141: 0x3001,
1204     0x8142: 0x3002,
1205     0x8143: 0xFF0C,
1206     0x8144: 0xFF0E,
1207     0x8145: 0x30FB,
1208     0x8146: 0xFF1A,
1209     0x8147: 0xFF1B,
1210     0x8148: 0xFF1F,
1211     0x8149: 0xFF01,
1212     0x814A: 0x309B,
1213     0x814B: 0x309C,
1214     0x814C: 0x00B4,
1215     0x814D: 0xFF40,
1216     0x814E: 0x00A8,
1217     0x814F: 0xFF3E,
1218     0x8150: 0xFFE3,
1219     0x8151: 0xFF3F,
1220     0x8152: 0x30FD,
1221     0x8153: 0x30FE,
1222     0x8154: 0x309D,
1223     0x8155: 0x309E,
1224     0x8156: 0x3003,
1225     0x8157: 0x4EDD,
1226     0x8158: 0x3005,
1227     0x8159: 0x3006,
1228     0x815A: 0x3007,
1229     0x815B: 0x30FC,
1230     0x815C: 0x2015,
1231     0x815D: 0x2010,
1232     0x815E: 0xFF0F,
1233     0x815F: 0x005C,
1234     0x8160: 0x301C,
1235     0x8161: 0x2016,
1236     0x8162: 0xFF5C,
1237     0x8163: 0x2026,
1238     0x8164: 0x2025,
1239     0x8165: 0x2018,
1240     0x8166: 0x2019,
1241     0x8167: 0x201C,
1242     0x8168: 0x201D,
1243     0x8169: 0xFF08,
1244     0x816A: 0xFF09,
1245     0x816B: 0x3014,
1246     0x816C: 0x3015,
1247     0x816D: 0xFF3B,
1248     0x816E: 0xFF3D,
1249     0x816F: 0xFF5B,
1250     0x8170: 0xFF5D,
1251     0x8171: 0x3008,
1252     0x8172: 0x3009,
1253     0x8173: 0x300A,
1254     0x8174: 0x300B,
1255     0x8175: 0x300C,
1256     0x8176: 0x300D,
1257     0x8177: 0x300E,
1258     0x8178: 0x300F,
1259     0x8179: 0x3010,
1260     0x817A: 0x3011,
1261     0x817B: 0xFF0B,
1262     0x817C: 0x2212,
1263     0x817D: 0x00B1,
1264     0x817E: 0x00D7,
1265     0x8180: 0x00F7,
1266     0x8181: 0xFF1D,
1267     0x8182: 0x2260,
1268     0x8183: 0xFF1C,
1269     0x8184: 0xFF1E,
1270     0x8185: 0x2266,
1271     0x8186: 0x2267,
1272     0x8187: 0x221E,
1273     0x8188: 0x2234,
1274     0x8189: 0x2642,
1275     0x818A: 0x2640,
1276     0x818B: 0x00B0,
1277     0x818C: 0x2032,
1278     0x818D: 0x2033,
1279     0x818E: 0x2103,
1280     0x818F: 0xFFE5,
1281     0x8190: 0xFF04,
1282     0x8191: 0x00A2,
1283     0x8192: 0x00A3,
1284     0x8193: 0xFF05,
1285     0x8194: 0xFF03,
1286     0x8195: 0xFF06,
1287     0x8196: 0xFF0A,
1288     0x8197: 0xFF20,
1289     0x8198: 0x00A7,
1290     0x8199: 0x2606,
1291     0x819A: 0x2605,
1292     0x819B: 0x25CB,
1293     0x819C: 0x25CF,
1294     0x819D: 0x25CE,
1295     0x819E: 0x25C7,
1296     0x819F: 0x25C6,
1297     0x81A0: 0x25A1,
1298     0x81A1: 0x25A0,
1299     0x81A2: 0x25B3,
1300     0x81A3: 0x25B2,
1301     0x81A4: 0x25BD,
1302     0x81A5: 0x25BC,
1303     0x81A6: 0x203B,
1304     0x81A7: 0x3012,
1305     0x81A8: 0x2192,
1306     0x81A9: 0x2190,
1307     0x81AA: 0x2191,
1308     0x81AB: 0x2193,
1309     0x81AC: 0x3013,
1310     0x81B8: 0x2208,
1311     0x81B9: 0x220B,
1312     0x81BA: 0x2286,
1313     0x81BB: 0x2287,
1314     0x81BC: 0x2282,
1315     0x81BD: 0x2283,
1316     0x81BE: 0x222A,
1317     0x81BF: 0x2229,
1318     0x81C8: 0x2227,
1319     0x81C9: 0x2228,
1320     0x81CA: 0x00AC,
1321     0x81CB: 0x21D2,
1322     0x81CC: 0x21D4,
1323     0x81CD: 0x2200,
1324     0x81CE: 0x2203,
1325     0x81DA: 0x2220,
1326     0x81DB: 0x22A5,
1327     0x81DC: 0x2312,
1328     0x81DD: 0x2202,
1329     0x81DE: 0x2207,
1330     0x81DF: 0x2261,
1331     0x81E0: 0x2252,
1332     0x81E1: 0x226A,
1333     0x81E2: 0x226B,
1334     0x81E3: 0x221A,
1335     0x81E4: 0x223D,
1336     0x81E5: 0x221D,
1337     0x81E6: 0x2235,
1338     0x81E7: 0x222B,
1339     0x81E8: 0x222C,
1340     0x81F0: 0x212B,
1341     0x81F1: 0x2030,
1342     0x81F2: 0x266F,
1343     0x81F3: 0x266D,
1344     0x81F4: 0x266A,
1345     0x81F5: 0x2020,
1346     0x81F6: 0x2021,
1347     0x81F7: 0x00B6,
1348     0x81FC: 0x25EF,
1349     0x824F: 0xFF10,
1350     0x8250: 0xFF11,
1351     0x8251: 0xFF12,
1352     0x8252: 0xFF13,
1353     0x8253: 0xFF14,
1354     0x8254: 0xFF15,
1355     0x8255: 0xFF16,
1356     0x8256: 0xFF17,
1357     0x8257: 0xFF18,
1358     0x8258: 0xFF19,
1359     0x8260: 0xFF21,
1360     0x8261: 0xFF22,
1361     0x8262: 0xFF23,
1362     0x8263: 0xFF24,
1363     0x8264: 0xFF25,
1364     0x8265: 0xFF26,
1365     0x8266: 0xFF27,
1366     0x8267: 0xFF28,
1367     0x8268: 0xFF29,
1368     0x8269: 0xFF2A,
1369     0x826A: 0xFF2B,
1370     0x826B: 0xFF2C,
1371     0x826C: 0xFF2D,
1372     0x826D: 0xFF2E,
1373     0x826E: 0xFF2F,
1374     0x826F: 0xFF30,
1375     0x8270: 0xFF31,
1376     0x8271: 0xFF32,
1377     0x8272: 0xFF33,
1378     0x8273: 0xFF34,
1379     0x8274: 0xFF35,
1380     0x8275: 0xFF36,
1381     0x8276: 0xFF37,
1382     0x8277: 0xFF38,
1383     0x8278: 0xFF39,
1384     0x8279: 0xFF3A,
1385     0x8281: 0xFF41,
1386     0x8282: 0xFF42,
1387     0x8283: 0xFF43,
1388     0x8284: 0xFF44,
1389     0x8285: 0xFF45,
1390     0x8286: 0xFF46,
1391     0x8287: 0xFF47,
1392     0x8288: 0xFF48,
1393     0x8289: 0xFF49,
1394     0x828A: 0xFF4A,
1395     0x828B: 0xFF4B,
1396     0x828C: 0xFF4C,
1397     0x828D: 0xFF4D,
1398     0x828E: 0xFF4E,
1399     0x828F: 0xFF4F,
1400     0x8290: 0xFF50,
1401     0x8291: 0xFF51,
1402     0x8292: 0xFF52,
1403     0x8293: 0xFF53,
1404     0x8294: 0xFF54,
1405     0x8295: 0xFF55,
1406     0x8296: 0xFF56,
1407     0x8297: 0xFF57,
1408     0x8298: 0xFF58,
1409     0x8299: 0xFF59,
1410     0x829A: 0xFF5A,
1411     0x829F: 0x3041,
1412     0x82A0: 0x3042,
1413     0x82A1: 0x3043,
1414     0x82A2: 0x3044,
1415     0x82A3: 0x3045,
1416     0x82A4: 0x3046,
1417     0x82A5: 0x3047,
1418     0x82A6: 0x3048,
1419     0x82A7: 0x3049,
1420     0x82A8: 0x304A,
1421     0x82A9: 0x304B,
1422     0x82AA: 0x304C,
1423     0x82AB: 0x304D,
1424     0x82AC: 0x304E,
1425     0x82AD: 0x304F,
1426     0x82AE: 0x3050,
1427     0x82AF: 0x3051,
1428     0x82B0: 0x3052,
1429     0x82B1: 0x3053,
1430     0x82B2: 0x3054,
1431     0x82B3: 0x3055,
1432     0x82B4: 0x3056,
1433     0x82B5: 0x3057,
1434     0x82B6: 0x3058,
1435     0x82B7: 0x3059,
1436     0x82B8: 0x305A,
1437     0x82B9: 0x305B,
1438     0x82BA: 0x305C,
1439     0x82BB: 0x305D,
1440     0x82BC: 0x305E,
1441     0x82BD: 0x305F,
1442     0x82BE: 0x3060,
1443     0x82BF: 0x3061,
1444     0x82C0: 0x3062,
1445     0x82C1: 0x3063,
1446     0x82C2: 0x3064,
1447     0x82C3: 0x3065,
1448     0x82C4: 0x3066,
1449     0x82C5: 0x3067,
1450     0x82C6: 0x3068,
1451     0x82C7: 0x3069,
1452     0x82C8: 0x306A,
1453     0x82C9: 0x306B,
1454     0x82CA: 0x306C,
1455     0x82CB: 0x306D,
1456     0x82CC: 0x306E,
1457     0x82CD: 0x306F,
1458     0x82CE: 0x3070,
1459     0x82CF: 0x3071,
1460     0x82D0: 0x3072,
1461     0x82D1: 0x3073,
1462     0x82D2: 0x3074,
1463     0x82D3: 0x3075,
1464     0x82D4: 0x3076,
1465     0x82D5: 0x3077,
1466     0x82D6: 0x3078,
1467     0x82D7: 0x3079,
1468     0x82D8: 0x307A,
1469     0x82D9: 0x307B,
1470     0x82DA: 0x307C,
1471     0x82DB: 0x307D,
1472     0x82DC: 0x307E,
1473     0x82DD: 0x307F,
1474     0x82DE: 0x3080,
1475     0x82DF: 0x3081,
1476     0x82E0: 0x3082,
1477     0x82E1: 0x3083,
1478     0x82E2: 0x3084,
1479     0x82E3: 0x3085,
1480     0x82E4: 0x3086,
1481     0x82E5: 0x3087,
1482     0x82E6: 0x3088,
1483     0x82E7: 0x3089,
1484     0x82E8: 0x308A,
1485     0x82E9: 0x308B,
1486     0x82EA: 0x308C,
1487     0x82EB: 0x308D,
1488     0x82EC: 0x308E,
1489     0x82ED: 0x308F,
1490     0x82EE: 0x3090,
1491     0x82EF: 0x3091,
1492     0x82F0: 0x3092,
1493     0x82F1: 0x3093,
1494     0x8340: 0x30A1,
1495     0x8341: 0x30A2,
1496     0x8342: 0x30A3,
1497     0x8343: 0x30A4,
1498     0x8344: 0x30A5,
1499     0x8345: 0x30A6,
1500     0x8346: 0x30A7,
1501     0x8347: 0x30A8,
1502     0x8348: 0x30A9,
1503     0x8349: 0x30AA,
1504     0x834A: 0x30AB,
1505     0x834B: 0x30AC,
1506     0x834C: 0x30AD,
1507     0x834D: 0x30AE,
1508     0x834E: 0x30AF,
1509     0x834F: 0x30B0,
1510     0x8350: 0x30B1,
1511     0x8351: 0x30B2,
1512     0x8352: 0x30B3,
1513     0x8353: 0x30B4,
1514     0x8354: 0x30B5,
1515     0x8355: 0x30B6,
1516     0x8356: 0x30B7,
1517     0x8357: 0x30B8,
1518     0x8358: 0x30B9,
1519     0x8359: 0x30BA,
1520     0x835A: 0x30BB,
1521     0x835B: 0x30BC,
1522     0x835C: 0x30BD,
1523     0x835D: 0x30BE,
1524     0x835E: 0x30BF,
1525     0x835F: 0x30C0,
1526     0x8360: 0x30C1,
1527     0x8361: 0x30C2,
1528     0x8362: 0x30C3,
1529     0x8363: 0x30C4,
1530     0x8364: 0x30C5,
1531     0x8365: 0x30C6,
1532     0x8366: 0x30C7,
1533     0x8367: 0x30C8,
1534     0x8368: 0x30C9,
1535     0x8369: 0x30CA,
1536     0x836A: 0x30CB,
1537     0x836B: 0x30CC,
1538     0x836C: 0x30CD,
1539     0x836D: 0x30CE,
1540     0x836E: 0x30CF,
1541     0x836F: 0x30D0,
1542     0x8370: 0x30D1,
1543     0x8371: 0x30D2,
1544     0x8372: 0x30D3,
1545     0x8373: 0x30D4,
1546     0x8374: 0x30D5,
1547     0x8375: 0x30D6,
1548     0x8376: 0x30D7,
1549     0x8377: 0x30D8,
1550     0x8378: 0x30D9,
1551     0x8379: 0x30DA,
1552     0x837A: 0x30DB,
1553     0x837B: 0x30DC,
1554     0x837C: 0x30DD,
1555     0x837D: 0x30DE,
1556     0x837E: 0x30DF,
1557     0x8380: 0x30E0,
1558     0x8381: 0x30E1,
1559     0x8382: 0x30E2,
1560     0x8383: 0x30E3,
1561     0x8384: 0x30E4,
1562     0x8385: 0x30E5,
1563     0x8386: 0x30E6,
1564     0x8387: 0x30E7,
1565     0x8388: 0x30E8,
1566     0x8389: 0x30E9,
1567     0x838A: 0x30EA,
1568     0x838B: 0x30EB,
1569     0x838C: 0x30EC,
1570     0x838D: 0x30ED,
1571     0x838E: 0x30EE,
1572     0x838F: 0x30EF,
1573     0x8390: 0x30F0,
1574     0x8391: 0x30F1,
1575     0x8392: 0x30F2,
1576     0x8393: 0x30F3,
1577     0x8394: 0x30F4,
1578     0x8395: 0x30F5,
1579     0x8396: 0x30F6,
1580     0x839F: 0x0391,
1581     0x83A0: 0x0392,
1582     0x83A1: 0x0393,
1583     0x83A2: 0x0394,
1584     0x83A3: 0x0395,
1585     0x83A4: 0x0396,
1586     0x83A5: 0x0397,
1587     0x83A6: 0x0398,
1588     0x83A7: 0x0399,
1589     0x83A8: 0x039A,
1590     0x83A9: 0x039B,
1591     0x83AA: 0x039C,
1592     0x83AB: 0x039D,
1593     0x83AC: 0x039E,
1594     0x83AD: 0x039F,
1595     0x83AE: 0x03A0,
1596     0x83AF: 0x03A1,
1597     0x83B0: 0x03A3,
1598     0x83B1: 0x03A4,
1599     0x83B2: 0x03A5,
1600     0x83B3: 0x03A6,
1601     0x83B4: 0x03A7,
1602     0x83B5: 0x03A8,
1603     0x83B6: 0x03A9,
1604     0x83BF: 0x03B1,
1605     0x83C0: 0x03B2,
1606     0x83C1: 0x03B3,
1607     0x83C2: 0x03B4,
1608     0x83C3: 0x03B5,
1609     0x83C4: 0x03B6,
1610     0x83C5: 0x03B7,
1611     0x83C6: 0x03B8,
1612     0x83C7: 0x03B9,
1613     0x83C8: 0x03BA,
1614     0x83C9: 0x03BB,
1615     0x83CA: 0x03BC,
1616     0x83CB: 0x03BD,
1617     0x83CC: 0x03BE,
1618     0x83CD: 0x03BF,
1619     0x83CE: 0x03C0,
1620     0x83CF: 0x03C1,
1621     0x83D0: 0x03C3,
1622     0x83D1: 0x03C4,
1623     0x83D2: 0x03C5,
1624     0x83D3: 0x03C6,
1625     0x83D4: 0x03C7,
1626     0x83D5: 0x03C8,
1627     0x83D6: 0x03C9,
1628     0x8440: 0x0410,
1629     0x8441: 0x0411,
1630     0x8442: 0x0412,
1631     0x8443: 0x0413,
1632     0x8444: 0x0414,
1633     0x8445: 0x0415,
1634     0x8446: 0x0401,
1635     0x8447: 0x0416,
1636     0x8448: 0x0417,
1637     0x8449: 0x0418,
1638     0x844A: 0x0419,
1639     0x844B: 0x041A,
1640     0x844C: 0x041B,
1641     0x844D: 0x041C,
1642     0x844E: 0x041D,
1643     0x844F: 0x041E,
1644     0x8450: 0x041F,
1645     0x8451: 0x0420,
1646     0x8452: 0x0421,
1647     0x8453: 0x0422,
1648     0x8454: 0x0423,
1649     0x8455: 0x0424,
1650     0x8456: 0x0425,
1651     0x8457: 0x0426,
1652     0x8458: 0x0427,
1653     0x8459: 0x0428,
1654     0x845A: 0x0429,
1655     0x845B: 0x042A,
1656     0x845C: 0x042B,
1657     0x845D: 0x042C,
1658     0x845E: 0x042D,
1659     0x845F: 0x042E,
1660     0x8460: 0x042F,
1661     0x8470: 0x0430,
1662     0x8471: 0x0431,
1663     0x8472: 0x0432,
1664     0x8473: 0x0433,
1665     0x8474: 0x0434,
1666     0x8475: 0x0435,
1667     0x8476: 0x0451,
1668     0x8477: 0x0436,
1669     0x8478: 0x0437,
1670     0x8479: 0x0438,
1671     0x847A: 0x0439,
1672     0x847B: 0x043A,
1673     0x847C: 0x043B,
1674     0x847D: 0x043C,
1675     0x847E: 0x043D,
1676     0x8480: 0x043E,
1677     0x8481: 0x043F,
1678     0x8482: 0x0440,
1679     0x8483: 0x0441,
1680     0x8484: 0x0442,
1681     0x8485: 0x0443,
1682     0x8486: 0x0444,
1683     0x8487: 0x0445,
1684     0x8488: 0x0446,
1685     0x8489: 0x0447,
1686     0x848A: 0x0448,
1687     0x848B: 0x0449,
1688     0x848C: 0x044A,
1689     0x848D: 0x044B,
1690     0x848E: 0x044C,
1691     0x848F: 0x044D,
1692     0x8490: 0x044E,
1693     0x8491: 0x044F,
1694     0x849F: 0x2500,
1695     0x84A0: 0x2502,
1696     0x84A1: 0x250C,
1697     0x84A2: 0x2510,
1698     0x84A3: 0x2518,
1699     0x84A4: 0x2514,
1700     0x84A5: 0x251C,
1701     0x84A6: 0x252C,
1702     0x84A7: 0x2524,
1703     0x84A8: 0x2534,
1704     0x84A9: 0x253C,
1705     0x84AA: 0x2501,
1706     0x84AB: 0x2503,
1707     0x84AC: 0x250F,
1708     0x84AD: 0x2513,
1709     0x84AE: 0x251B,
1710     0x84AF: 0x2517,
1711     0x84B0: 0x2523,
1712     0x84B1: 0x2533,
1713     0x84B2: 0x252B,
1714     0x84B3: 0x253B,
1715     0x84B4: 0x254B,
1716     0x84B5: 0x2520,
1717     0x84B6: 0x252F,
1718     0x84B7: 0x2528,
1719     0x84B8: 0x2537,
1720     0x84B9: 0x253F,
1721     0x84BA: 0x251D,
1722     0x84BB: 0x2530,
1723     0x84BC: 0x2525,
1724     0x84BD: 0x2538,
1725     0x84BE: 0x2542,
1726     0x889F: 0x4E9C,
1727     0x88A0: 0x5516,
1728     0x88A1: 0x5A03,
1729     0x88A2: 0x963F,
1730     0x88A3: 0x54C0,
1731     0x88A4: 0x611B,
1732     0x88A5: 0x6328,
1733     0x88A6: 0x59F6,
1734     0x88A7: 0x9022,
1735     0x88A8: 0x8475,
1736     0x88A9: 0x831C,
1737     0x88AA: 0x7A50,
1738     0x88AB: 0x60AA,
1739     0x88AC: 0x63E1,
1740     0x88AD: 0x6E25,
1741     0x88AE: 0x65ED,
1742     0x88AF: 0x8466,
1743     0x88B0: 0x82A6,
1744     0x88B1: 0x9BF5,
1745     0x88B2: 0x6893,
1746     0x88B3: 0x5727,
1747     0x88B4: 0x65A1,
1748     0x88B5: 0x6271,
1749     0x88B6: 0x5B9B,
1750     0x88B7: 0x59D0,
1751     0x88B8: 0x867B,
1752     0x88B9: 0x98F4,
1753     0x88BA: 0x7D62,
1754     0x88BB: 0x7DBE,
1755     0x88BC: 0x9B8E,
1756     0x88BD: 0x6216,
1757     0x88BE: 0x7C9F,
1758     0x88BF: 0x88B7,
1759     0x88C0: 0x5B89,
1760     0x88C1: 0x5EB5,
1761     0x88C2: 0x6309,
1762     0x88C3: 0x6697,
1763     0x88C4: 0x6848,
1764     0x88C5: 0x95C7,
1765     0x88C6: 0x978D,
1766     0x88C7: 0x674F,
1767     0x88C8: 0x4EE5,
1768     0x88C9: 0x4F0A,
1769     0x88CA: 0x4F4D,
1770     0x88CB: 0x4F9D,
1771     0x88CC: 0x5049,
1772     0x88CD: 0x56F2,
1773     0x88CE: 0x5937,
1774     0x88CF: 0x59D4,
1775     0x88D0: 0x5A01,
1776     0x88D1: 0x5C09,
1777     0x88D2: 0x60DF,
1778     0x88D3: 0x610F,
1779     0x88D4: 0x6170,
1780     0x88D5: 0x6613,
1781     0x88D6: 0x6905,
1782     0x88D7: 0x70BA,
1783     0x88D8: 0x754F,
1784     0x88D9: 0x7570,
1785     0x88DA: 0x79FB,
1786     0x88DB: 0x7DAD,
1787     0x88DC: 0x7DEF,
1788     0x88DD: 0x80C3,
1789     0x88DE: 0x840E,
1790     0x88DF: 0x8863,
1791     0x88E0: 0x8B02,
1792     0x88E1: 0x9055,
1793     0x88E2: 0x907A,
1794     0x88E3: 0x533B,
1795     0x88E4: 0x4E95,
1796     0x88E5: 0x4EA5,
1797     0x88E6: 0x57DF,
1798     0x88E7: 0x80B2,
1799     0x88E8: 0x90C1,
1800     0x88E9: 0x78EF,
1801     0x88EA: 0x4E00,
1802     0x88EB: 0x58F1,
1803     0x88EC: 0x6EA2,
1804     0x88ED: 0x9038,
1805     0x88EE: 0x7A32,
1806     0x88EF: 0x8328,
1807     0x88F0: 0x828B,
1808     0x88F1: 0x9C2F,
1809     0x88F2: 0x5141,
1810     0x88F3: 0x5370,
1811     0x88F4: 0x54BD,
1812     0x88F5: 0x54E1,
1813     0x88F6: 0x56E0,
1814     0x88F7: 0x59FB,
1815     0x88F8: 0x5F15,
1816     0x88F9: 0x98F2,
1817     0x88FA: 0x6DEB,
1818     0x88FB: 0x80E4,
1819     0x88FC: 0x852D,
1820     0x8940: 0x9662,
1821     0x8941: 0x9670,
1822     0x8942: 0x96A0,
1823     0x8943: 0x97FB,
1824     0x8944: 0x540B,
1825     0x8945: 0x53F3,
1826     0x8946: 0x5B87,
1827     0x8947: 0x70CF,
1828     0x8948: 0x7FBD,
1829     0x8949: 0x8FC2,
1830     0x894A: 0x96E8,
1831     0x894B: 0x536F,
1832     0x894C: 0x9D5C,
1833     0x894D: 0x7ABA,
1834     0x894E: 0x4E11,
1835     0x894F: 0x7893,
1836     0x8950: 0x81FC,
1837     0x8951: 0x6E26,
1838     0x8952: 0x5618,
1839     0x8953: 0x5504,
1840     0x8954: 0x6B1D,
1841     0x8955: 0x851A,
1842     0x8956: 0x9C3B,
1843     0x8957: 0x59E5,
1844     0x8958: 0x53A9,
1845     0x8959: 0x6D66,
1846     0x895A: 0x74DC,
1847     0x895B: 0x958F,
1848     0x895C: 0x5642,
1849     0x895D: 0x4E91,
1850     0x895E: 0x904B,
1851     0x895F: 0x96F2,
1852     0x8960: 0x834F,
1853     0x8961: 0x990C,
1854     0x8962: 0x53E1,
1855     0x8963: 0x55B6,
1856     0x8964: 0x5B30,
1857     0x8965: 0x5F71,
1858     0x8966: 0x6620,
1859     0x8967: 0x66F3,
1860     0x8968: 0x6804,
1861     0x8969: 0x6C38,
1862     0x896A: 0x6CF3,
1863     0x896B: 0x6D29,
1864     0x896C: 0x745B,
1865     0x896D: 0x76C8,
1866     0x896E: 0x7A4E,
1867     0x896F: 0x9834,
1868     0x8970: 0x82F1,
1869     0x8971: 0x885B,
1870     0x8972: 0x8A60,
1871     0x8973: 0x92ED,
1872     0x8974: 0x6DB2,
1873     0x8975: 0x75AB,
1874     0x8976: 0x76CA,
1875     0x8977: 0x99C5,
1876     0x8978: 0x60A6,
1877     0x8979: 0x8B01,
1878     0x897A: 0x8D8A,
1879     0x897B: 0x95B2,
1880     0x897C: 0x698E,
1881     0x897D: 0x53AD,
1882     0x897E: 0x5186,
1883     0x8980: 0x5712,
1884     0x8981: 0x5830,
1885     0x8982: 0x5944,
1886     0x8983: 0x5BB4,
1887     0x8984: 0x5EF6,
1888     0x8985: 0x6028,
1889     0x8986: 0x63A9,
1890     0x8987: 0x63F4,
1891     0x8988: 0x6CBF,
1892     0x8989: 0x6F14,
1893     0x898A: 0x708E,
1894     0x898B: 0x7114,
1895     0x898C: 0x7159,
1896     0x898D: 0x71D5,
1897     0x898E: 0x733F,
1898     0x898F: 0x7E01,
1899     0x8990: 0x8276,
1900     0x8991: 0x82D1,
1901     0x8992: 0x8597,
1902     0x8993: 0x9060,
1903     0x8994: 0x925B,
1904     0x8995: 0x9D1B,
1905     0x8996: 0x5869,
1906     0x8997: 0x65BC,
1907     0x8998: 0x6C5A,
1908     0x8999: 0x7525,
1909     0x899A: 0x51F9,
1910     0x899B: 0x592E,
1911     0x899C: 0x5965,
1912     0x899D: 0x5F80,
1913     0x899E: 0x5FDC,
1914     0x899F: 0x62BC,
1915     0x89A0: 0x65FA,
1916     0x89A1: 0x6A2A,
1917     0x89A2: 0x6B27,
1918     0x89A3: 0x6BB4,
1919     0x89A4: 0x738B,
1920     0x89A5: 0x7FC1,
1921     0x89A6: 0x8956,
1922     0x89A7: 0x9D2C,
1923     0x89A8: 0x9D0E,
1924     0x89A9: 0x9EC4,
1925     0x89AA: 0x5CA1,
1926     0x89AB: 0x6C96,
1927     0x89AC: 0x837B,
1928     0x89AD: 0x5104,
1929     0x89AE: 0x5C4B,
1930     0x89AF: 0x61B6,
1931     0x89B0: 0x81C6,
1932     0x89B1: 0x6876,
1933     0x89B2: 0x7261,
1934     0x89B3: 0x4E59,
1935     0x89B4: 0x4FFA,
1936     0x89B5: 0x5378,
1937     0x89B6: 0x6069,
1938     0x89B7: 0x6E29,
1939     0x89B8: 0x7A4F,
1940     0x89B9: 0x97F3,
1941     0x89BA: 0x4E0B,
1942     0x89BB: 0x5316,
1943     0x89BC: 0x4EEE,
1944     0x89BD: 0x4F55,
1945     0x89BE: 0x4F3D,
1946     0x89BF: 0x4FA1,
1947     0x89C0: 0x4F73,
1948     0x89C1: 0x52A0,
1949     0x89C2: 0x53EF,
1950     0x89C3: 0x5609,
1951     0x89C4: 0x590F,
1952     0x89C5: 0x5AC1,
1953     0x89C6: 0x5BB6,
1954     0x89C7: 0x5BE1,
1955     0x89C8: 0x79D1,
1956     0x89C9: 0x6687,
1957     0x89CA: 0x679C,
1958     0x89CB: 0x67B6,
1959     0x89CC: 0x6B4C,
1960     0x89CD: 0x6CB3,
1961     0x89CE: 0x706B,
1962     0x89CF: 0x73C2,
1963     0x89D0: 0x798D,
1964     0x89D1: 0x79BE,
1965     0x89D2: 0x7A3C,
1966     0x89D3: 0x7B87,
1967     0x89D4: 0x82B1,
1968     0x89D5: 0x82DB,
1969     0x89D6: 0x8304,
1970     0x89D7: 0x8377,
1971     0x89D8: 0x83EF,
1972     0x89D9: 0x83D3,
1973     0x89DA: 0x8766,
1974     0x89DB: 0x8AB2,
1975     0x89DC: 0x5629,
1976     0x89DD: 0x8CA8,
1977     0x89DE: 0x8FE6,
1978     0x89DF: 0x904E,
1979     0x89E0: 0x971E,
1980     0x89E1: 0x868A,
1981     0x89E2: 0x4FC4,
1982     0x89E3: 0x5CE8,
1983     0x89E4: 0x6211,
1984     0x89E5: 0x7259,
1985     0x89E6: 0x753B,
1986     0x89E7: 0x81E5,
1987     0x89E8: 0x82BD,
1988     0x89E9: 0x86FE,
1989     0x89EA: 0x8CC0,
1990     0x89EB: 0x96C5,
1991     0x89EC: 0x9913,
1992     0x89ED: 0x99D5,
1993     0x89EE: 0x4ECB,
1994     0x89EF: 0x4F1A,
1995     0x89F0: 0x89E3,
1996     0x89F1: 0x56DE,
1997     0x89F2: 0x584A,
1998     0x89F3: 0x58CA,
1999     0x89F4: 0x5EFB,
2000     0x89F5: 0x5FEB,
2001     0x89F6: 0x602A,
2002     0x89F7: 0x6094,
2003     0x89F8: 0x6062,
2004     0x89F9: 0x61D0,
2005     0x89FA: 0x6212,
2006     0x89FB: 0x62D0,
2007     0x89FC: 0x6539,
2008     0x8A40: 0x9B41,
2009     0x8A41: 0x6666,
2010     0x8A42: 0x68B0,
2011     0x8A43: 0x6D77,
2012     0x8A44: 0x7070,
2013     0x8A45: 0x754C,
2014     0x8A46: 0x7686,
2015     0x8A47: 0x7D75,
2016     0x8A48: 0x82A5,
2017     0x8A49: 0x87F9,
2018     0x8A4A: 0x958B,
2019     0x8A4B: 0x968E,
2020     0x8A4C: 0x8C9D,
2021     0x8A4D: 0x51F1,
2022     0x8A4E: 0x52BE,
2023     0x8A4F: 0x5916,
2024     0x8A50: 0x54B3,
2025     0x8A51: 0x5BB3,
2026     0x8A52: 0x5D16,
2027     0x8A53: 0x6168,
2028     0x8A54: 0x6982,
2029     0x8A55: 0x6DAF,
2030     0x8A56: 0x788D,
2031     0x8A57: 0x84CB,
2032     0x8A58: 0x8857,
2033     0x8A59: 0x8A72,
2034     0x8A5A: 0x93A7,
2035     0x8A5B: 0x9AB8,
2036     0x8A5C: 0x6D6C,
2037     0x8A5D: 0x99A8,
2038     0x8A5E: 0x86D9,
2039     0x8A5F: 0x57A3,
2040     0x8A60: 0x67FF,
2041     0x8A61: 0x86CE,
2042     0x8A62: 0x920E,
2043     0x8A63: 0x5283,
2044     0x8A64: 0x5687,
2045     0x8A65: 0x5404,
2046     0x8A66: 0x5ED3,
2047     0x8A67: 0x62E1,
2048     0x8A68: 0x64B9,
2049     0x8A69: 0x683C,
2050     0x8A6A: 0x6838,
2051     0x8A6B: 0x6BBB,
2052     0x8A6C: 0x7372,
2053     0x8A6D: 0x78BA,
2054     0x8A6E: 0x7A6B,
2055     0x8A6F: 0x899A,
2056     0x8A70: 0x89D2,
2057     0x8A71: 0x8D6B,
2058     0x8A72: 0x8F03,
2059     0x8A73: 0x90ED,
2060     0x8A74: 0x95A3,
2061     0x8A75: 0x9694,
2062     0x8A76: 0x9769,
2063     0x8A77: 0x5B66,
2064     0x8A78: 0x5CB3,
2065     0x8A79: 0x697D,
2066     0x8A7A: 0x984D,
2067     0x8A7B: 0x984E,
2068     0x8A7C: 0x639B,
2069     0x8A7D: 0x7B20,
2070     0x8A7E: 0x6A2B,
2071     0x8A80: 0x6A7F,
2072     0x8A81: 0x68B6,
2073     0x8A82: 0x9C0D,
2074     0x8A83: 0x6F5F,
2075     0x8A84: 0x5272,
2076     0x8A85: 0x559D,
2077     0x8A86: 0x6070,
2078     0x8A87: 0x62EC,
2079     0x8A88: 0x6D3B,
2080     0x8A89: 0x6E07,
2081     0x8A8A: 0x6ED1,
2082     0x8A8B: 0x845B,
2083     0x8A8C: 0x8910,
2084     0x8A8D: 0x8F44,
2085     0x8A8E: 0x4E14,
2086     0x8A8F: 0x9C39,
2087     0x8A90: 0x53F6,
2088     0x8A91: 0x691B,
2089     0x8A92: 0x6A3A,
2090     0x8A93: 0x9784,
2091     0x8A94: 0x682A,
2092     0x8A95: 0x515C,
2093     0x8A96: 0x7AC3,
2094     0x8A97: 0x84B2,
2095     0x8A98: 0x91DC,
2096     0x8A99: 0x938C,
2097     0x8A9A: 0x565B,
2098     0x8A9B: 0x9D28,
2099     0x8A9C: 0x6822,
2100     0x8A9D: 0x8305,
2101     0x8A9E: 0x8431,
2102     0x8A9F: 0x7CA5,
2103     0x8AA0: 0x5208,
2104     0x8AA1: 0x82C5,
2105     0x8AA2: 0x74E6,
2106     0x8AA3: 0x4E7E,
2107     0x8AA4: 0x4F83,
2108     0x8AA5: 0x51A0,
2109     0x8AA6: 0x5BD2,
2110     0x8AA7: 0x520A,
2111     0x8AA8: 0x52D8,
2112     0x8AA9: 0x52E7,
2113     0x8AAA: 0x5DFB,
2114     0x8AAB: 0x559A,
2115     0x8AAC: 0x582A,
2116     0x8AAD: 0x59E6,
2117     0x8AAE: 0x5B8C,
2118     0x8AAF: 0x5B98,
2119     0x8AB0: 0x5BDB,
2120     0x8AB1: 0x5E72,
2121     0x8AB2: 0x5E79,
2122     0x8AB3: 0x60A3,
2123     0x8AB4: 0x611F,
2124     0x8AB5: 0x6163,
2125     0x8AB6: 0x61BE,
2126     0x8AB7: 0x63DB,
2127     0x8AB8: 0x6562,
2128     0x8AB9: 0x67D1,
2129     0x8ABA: 0x6853,
2130     0x8ABB: 0x68FA,
2131     0x8ABC: 0x6B3E,
2132     0x8ABD: 0x6B53,
2133     0x8ABE: 0x6C57,
2134     0x8ABF: 0x6F22,
2135     0x8AC0: 0x6F97,
2136     0x8AC1: 0x6F45,
2137     0x8AC2: 0x74B0,
2138     0x8AC3: 0x7518,
2139     0x8AC4: 0x76E3,
2140     0x8AC5: 0x770B,
2141     0x8AC6: 0x7AFF,
2142     0x8AC7: 0x7BA1,
2143     0x8AC8: 0x7C21,
2144     0x8AC9: 0x7DE9,
2145     0x8ACA: 0x7F36,
2146     0x8ACB: 0x7FF0,
2147     0x8ACC: 0x809D,
2148     0x8ACD: 0x8266,
2149     0x8ACE: 0x839E,
2150     0x8ACF: 0x89B3,
2151     0x8AD0: 0x8ACC,
2152     0x8AD1: 0x8CAB,
2153     0x8AD2: 0x9084,
2154     0x8AD3: 0x9451,
2155     0x8AD4: 0x9593,
2156     0x8AD5: 0x9591,
2157     0x8AD6: 0x95A2,
2158     0x8AD7: 0x9665,
2159     0x8AD8: 0x97D3,
2160     0x8AD9: 0x9928,
2161     0x8ADA: 0x8218,
2162     0x8ADB: 0x4E38,
2163     0x8ADC: 0x542B,
2164     0x8ADD: 0x5CB8,
2165     0x8ADE: 0x5DCC,
2166     0x8ADF: 0x73A9,
2167     0x8AE0: 0x764C,
2168     0x8AE1: 0x773C,
2169     0x8AE2: 0x5CA9,
2170     0x8AE3: 0x7FEB,
2171     0x8AE4: 0x8D0B,
2172     0x8AE5: 0x96C1,
2173     0x8AE6: 0x9811,
2174     0x8AE7: 0x9854,
2175     0x8AE8: 0x9858,
2176     0x8AE9: 0x4F01,
2177     0x8AEA: 0x4F0E,
2178     0x8AEB: 0x5371,
2179     0x8AEC: 0x559C,
2180     0x8AED: 0x5668,
2181     0x8AEE: 0x57FA,
2182     0x8AEF: 0x5947,
2183     0x8AF0: 0x5B09,
2184     0x8AF1: 0x5BC4,
2185     0x8AF2: 0x5C90,
2186     0x8AF3: 0x5E0C,
2187     0x8AF4: 0x5E7E,
2188     0x8AF5: 0x5FCC,
2189     0x8AF6: 0x63EE,
2190     0x8AF7: 0x673A,
2191     0x8AF8: 0x65D7,
2192     0x8AF9: 0x65E2,
2193     0x8AFA: 0x671F,
2194     0x8AFB: 0x68CB,
2195     0x8AFC: 0x68C4,
2196     0x8B40: 0x6A5F,
2197     0x8B41: 0x5E30,
2198     0x8B42: 0x6BC5,
2199     0x8B43: 0x6C17,
2200     0x8B44: 0x6C7D,
2201     0x8B45: 0x757F,
2202     0x8B46: 0x7948,
2203     0x8B47: 0x5B63,
2204     0x8B48: 0x7A00,
2205     0x8B49: 0x7D00,
2206     0x8B4A: 0x5FBD,
2207     0x8B4B: 0x898F,
2208     0x8B4C: 0x8A18,
2209     0x8B4D: 0x8CB4,
2210     0x8B4E: 0x8D77,
2211     0x8B4F: 0x8ECC,
2212     0x8B50: 0x8F1D,
2213     0x8B51: 0x98E2,
2214     0x8B52: 0x9A0E,
2215     0x8B53: 0x9B3C,
2216     0x8B54: 0x4E80,
2217     0x8B55: 0x507D,
2218     0x8B56: 0x5100,
2219     0x8B57: 0x5993,
2220     0x8B58: 0x5B9C,
2221     0x8B59: 0x622F,
2222     0x8B5A: 0x6280,
2223     0x8B5B: 0x64EC,
2224     0x8B5C: 0x6B3A,
2225     0x8B5D: 0x72A0,
2226     0x8B5E: 0x7591,
2227     0x8B5F: 0x7947,
2228     0x8B60: 0x7FA9,
2229     0x8B61: 0x87FB,
2230     0x8B62: 0x8ABC,
2231     0x8B63: 0x8B70,
2232     0x8B64: 0x63AC,
2233     0x8B65: 0x83CA,
2234     0x8B66: 0x97A0,
2235     0x8B67: 0x5409,
2236     0x8B68: 0x5403,
2237     0x8B69: 0x55AB,
2238     0x8B6A: 0x6854,
2239     0x8B6B: 0x6A58,
2240     0x8B6C: 0x8A70,
2241     0x8B6D: 0x7827,
2242     0x8B6E: 0x6775,
2243     0x8B6F: 0x9ECD,
2244     0x8B70: 0x5374,
2245     0x8B71: 0x5BA2,
2246     0x8B72: 0x811A,
2247     0x8B73: 0x8650,
2248     0x8B74: 0x9006,
2249     0x8B75: 0x4E18,
2250     0x8B76: 0x4E45,
2251     0x8B77: 0x4EC7,
2252     0x8B78: 0x4F11,
2253     0x8B79: 0x53CA,
2254     0x8B7A: 0x5438,
2255     0x8B7B: 0x5BAE,
2256     0x8B7C: 0x5F13,
2257     0x8B7D: 0x6025,
2258     0x8B7E: 0x6551,
2259     0x8B80: 0x673D,
2260     0x8B81: 0x6C42,
2261     0x8B82: 0x6C72,
2262     0x8B83: 0x6CE3,
2263     0x8B84: 0x7078,
2264     0x8B85: 0x7403,
2265     0x8B86: 0x7A76,
2266     0x8B87: 0x7AAE,
2267     0x8B88: 0x7B08,
2268     0x8B89: 0x7D1A,
2269     0x8B8A: 0x7CFE,
2270     0x8B8B: 0x7D66,
2271     0x8B8C: 0x65E7,
2272     0x8B8D: 0x725B,
2273     0x8B8E: 0x53BB,
2274     0x8B8F: 0x5C45,
2275     0x8B90: 0x5DE8,
2276     0x8B91: 0x62D2,
2277     0x8B92: 0x62E0,
2278     0x8B93: 0x6319,
2279     0x8B94: 0x6E20,
2280     0x8B95: 0x865A,
2281     0x8B96: 0x8A31,
2282     0x8B97: 0x8DDD,
2283     0x8B98: 0x92F8,
2284     0x8B99: 0x6F01,
2285     0x8B9A: 0x79A6,
2286     0x8B9B: 0x9B5A,
2287     0x8B9C: 0x4EA8,
2288     0x8B9D: 0x4EAB,
2289     0x8B9E: 0x4EAC,
2290     0x8B9F: 0x4F9B,
2291     0x8BA0: 0x4FA0,
2292     0x8BA1: 0x50D1,
2293     0x8BA2: 0x5147,
2294     0x8BA3: 0x7AF6,
2295     0x8BA4: 0x5171,
2296     0x8BA5: 0x51F6,
2297     0x8BA6: 0x5354,
2298     0x8BA7: 0x5321,
2299     0x8BA8: 0x537F,
2300     0x8BA9: 0x53EB,
2301     0x8BAA: 0x55AC,
2302     0x8BAB: 0x5883,
2303     0x8BAC: 0x5CE1,
2304     0x8BAD: 0x5F37,
2305     0x8BAE: 0x5F4A,
2306     0x8BAF: 0x602F,
2307     0x8BB0: 0x6050,
2308     0x8BB1: 0x606D,
2309     0x8BB2: 0x631F,
2310     0x8BB3: 0x6559,
2311     0x8BB4: 0x6A4B,
2312     0x8BB5: 0x6CC1,
2313     0x8BB6: 0x72C2,
2314     0x8BB7: 0x72ED,
2315     0x8BB8: 0x77EF,
2316     0x8BB9: 0x80F8,
2317     0x8BBA: 0x8105,
2318     0x8BBB: 0x8208,
2319     0x8BBC: 0x854E,
2320     0x8BBD: 0x90F7,
2321     0x8BBE: 0x93E1,
2322     0x8BBF: 0x97FF,
2323     0x8BC0: 0x9957,
2324     0x8BC1: 0x9A5A,
2325     0x8BC2: 0x4EF0,
2326     0x8BC3: 0x51DD,
2327     0x8BC4: 0x5C2D,
2328     0x8BC5: 0x6681,
2329     0x8BC6: 0x696D,
2330     0x8BC7: 0x5C40,
2331     0x8BC8: 0x66F2,
2332     0x8BC9: 0x6975,
2333     0x8BCA: 0x7389,
2334     0x8BCB: 0x6850,
2335     0x8BCC: 0x7C81,
2336     0x8BCD: 0x50C5,
2337     0x8BCE: 0x52E4,
2338     0x8BCF: 0x5747,
2339     0x8BD0: 0x5DFE,
2340     0x8BD1: 0x9326,
2341     0x8BD2: 0x65A4,
2342     0x8BD3: 0x6B23,
2343     0x8BD4: 0x6B3D,
2344     0x8BD5: 0x7434,
2345     0x8BD6: 0x7981,
2346     0x8BD7: 0x79BD,
2347     0x8BD8: 0x7B4B,
2348     0x8BD9: 0x7DCA,
2349     0x8BDA: 0x82B9,
2350     0x8BDB: 0x83CC,
2351     0x8BDC: 0x887F,
2352     0x8BDD: 0x895F,
2353     0x8BDE: 0x8B39,
2354     0x8BDF: 0x8FD1,
2355     0x8BE0: 0x91D1,
2356     0x8BE1: 0x541F,
2357     0x8BE2: 0x9280,
2358     0x8BE3: 0x4E5D,
2359     0x8BE4: 0x5036,
2360     0x8BE5: 0x53E5,
2361     0x8BE6: 0x533A,
2362     0x8BE7: 0x72D7,
2363     0x8BE8: 0x7396,
2364     0x8BE9: 0x77E9,
2365     0x8BEA: 0x82E6,
2366     0x8BEB: 0x8EAF,
2367     0x8BEC: 0x99C6,
2368     0x8BED: 0x99C8,
2369     0x8BEE: 0x99D2,
2370     0x8BEF: 0x5177,
2371     0x8BF0: 0x611A,
2372     0x8BF1: 0x865E,
2373     0x8BF2: 0x55B0,
2374     0x8BF3: 0x7A7A,
2375     0x8BF4: 0x5076,
2376     0x8BF5: 0x5BD3,
2377     0x8BF6: 0x9047,
2378     0x8BF7: 0x9685,
2379     0x8BF8: 0x4E32,
2380     0x8BF9: 0x6ADB,
2381     0x8BFA: 0x91E7,
2382     0x8BFB: 0x5C51,
2383     0x8BFC: 0x5C48,
2384     0x8C40: 0x6398,
2385     0x8C41: 0x7A9F,
2386     0x8C42: 0x6C93,
2387     0x8C43: 0x9774,
2388     0x8C44: 0x8F61,
2389     0x8C45: 0x7AAA,
2390     0x8C46: 0x718A,
2391     0x8C47: 0x9688,
2392     0x8C48: 0x7C82,
2393     0x8C49: 0x6817,
2394     0x8C4A: 0x7E70,
2395     0x8C4B: 0x6851,
2396     0x8C4C: 0x936C,
2397     0x8C4D: 0x52F2,
2398     0x8C4E: 0x541B,
2399     0x8C4F: 0x85AB,
2400     0x8C50: 0x8A13,
2401     0x8C51: 0x7FA4,
2402     0x8C52: 0x8ECD,
2403     0x8C53: 0x90E1,
2404     0x8C54: 0x5366,
2405     0x8C55: 0x8888,
2406     0x8C56: 0x7941,
2407     0x8C57: 0x4FC2,
2408     0x8C58: 0x50BE,
2409     0x8C59: 0x5211,
2410     0x8C5A: 0x5144,
2411     0x8C5B: 0x5553,
2412     0x8C5C: 0x572D,
2413     0x8C5D: 0x73EA,
2414     0x8C5E: 0x578B,
2415     0x8C5F: 0x5951,
2416     0x8C60: 0x5F62,
2417     0x8C61: 0x5F84,
2418     0x8C62: 0x6075,
2419     0x8C63: 0x6176,
2420     0x8C64: 0x6167,
2421     0x8C65: 0x61A9,
2422     0x8C66: 0x63B2,
2423     0x8C67: 0x643A,
2424     0x8C68: 0x656C,
2425     0x8C69: 0x666F,
2426     0x8C6A: 0x6842,
2427     0x8C6B: 0x6E13,
2428     0x8C6C: 0x7566,
2429     0x8C6D: 0x7A3D,
2430     0x8C6E: 0x7CFB,
2431     0x8C6F: 0x7D4C,
2432     0x8C70: 0x7D99,
2433     0x8C71: 0x7E4B,
2434     0x8C72: 0x7F6B,
2435     0x8C73: 0x830E,
2436     0x8C74: 0x834A,
2437     0x8C75: 0x86CD,
2438     0x8C76: 0x8A08,
2439     0x8C77: 0x8A63,
2440     0x8C78: 0x8B66,
2441     0x8C79: 0x8EFD,
2442     0x8C7A: 0x981A,
2443     0x8C7B: 0x9D8F,
2444     0x8C7C: 0x82B8,
2445     0x8C7D: 0x8FCE,
2446     0x8C7E: 0x9BE8,
2447     0x8C80: 0x5287,
2448     0x8C81: 0x621F,
2449     0x8C82: 0x6483,
2450     0x8C83: 0x6FC0,
2451     0x8C84: 0x9699,
2452     0x8C85: 0x6841,
2453     0x8C86: 0x5091,
2454     0x8C87: 0x6B20,
2455     0x8C88: 0x6C7A,
2456     0x8C89: 0x6F54,
2457     0x8C8A: 0x7A74,
2458     0x8C8B: 0x7D50,
2459     0x8C8C: 0x8840,
2460     0x8C8D: 0x8A23,
2461     0x8C8E: 0x6708,
2462     0x8C8F: 0x4EF6,
2463     0x8C90: 0x5039,
2464     0x8C91: 0x5026,
2465     0x8C92: 0x5065,
2466     0x8C93: 0x517C,
2467     0x8C94: 0x5238,
2468     0x8C95: 0x5263,
2469     0x8C96: 0x55A7,
2470     0x8C97: 0x570F,
2471     0x8C98: 0x5805,
2472     0x8C99: 0x5ACC,
2473     0x8C9A: 0x5EFA,
2474     0x8C9B: 0x61B2,
2475     0x8C9C: 0x61F8,
2476     0x8C9D: 0x62F3,
2477     0x8C9E: 0x6372,
2478     0x8C9F: 0x691C,
2479     0x8CA0: 0x6A29,
2480     0x8CA1: 0x727D,
2481     0x8CA2: 0x72AC,
2482     0x8CA3: 0x732E,
2483     0x8CA4: 0x7814,
2484     0x8CA5: 0x786F,
2485     0x8CA6: 0x7D79,
2486     0x8CA7: 0x770C,
2487     0x8CA8: 0x80A9,
2488     0x8CA9: 0x898B,
2489     0x8CAA: 0x8B19,
2490     0x8CAB: 0x8CE2,
2491     0x8CAC: 0x8ED2,
2492     0x8CAD: 0x9063,
2493     0x8CAE: 0x9375,
2494     0x8CAF: 0x967A,
2495     0x8CB0: 0x9855,
2496     0x8CB1: 0x9A13,
2497     0x8CB2: 0x9E78,
2498     0x8CB3: 0x5143,
2499     0x8CB4: 0x539F,
2500     0x8CB5: 0x53B3,
2501     0x8CB6: 0x5E7B,
2502     0x8CB7: 0x5F26,
2503     0x8CB8: 0x6E1B,
2504     0x8CB9: 0x6E90,
2505     0x8CBA: 0x7384,
2506     0x8CBB: 0x73FE,
2507     0x8CBC: 0x7D43,
2508     0x8CBD: 0x8237,
2509     0x8CBE: 0x8A00,
2510     0x8CBF: 0x8AFA,
2511     0x8CC0: 0x9650,
2512     0x8CC1: 0x4E4E,
2513     0x8CC2: 0x500B,
2514     0x8CC3: 0x53E4,
2515     0x8CC4: 0x547C,
2516     0x8CC5: 0x56FA,
2517     0x8CC6: 0x59D1,
2518     0x8CC7: 0x5B64,
2519     0x8CC8: 0x5DF1,
2520     0x8CC9: 0x5EAB,
2521     0x8CCA: 0x5F27,
2522     0x8CCB: 0x6238,
2523     0x8CCC: 0x6545,
2524     0x8CCD: 0x67AF,
2525     0x8CCE: 0x6E56,
2526     0x8CCF: 0x72D0,
2527     0x8CD0: 0x7CCA,
2528     0x8CD1: 0x88B4,
2529     0x8CD2: 0x80A1,
2530     0x8CD3: 0x80E1,
2531     0x8CD4: 0x83F0,
2532     0x8CD5: 0x864E,
2533     0x8CD6: 0x8A87,
2534     0x8CD7: 0x8DE8,
2535     0x8CD8: 0x9237,
2536     0x8CD9: 0x96C7,
2537     0x8CDA: 0x9867,
2538     0x8CDB: 0x9F13,
2539     0x8CDC: 0x4E94,
2540     0x8CDD: 0x4E92,
2541     0x8CDE: 0x4F0D,
2542     0x8CDF: 0x5348,
2543     0x8CE0: 0x5449,
2544     0x8CE1: 0x543E,
2545     0x8CE2: 0x5A2F,
2546     0x8CE3: 0x5F8C,
2547     0x8CE4: 0x5FA1,
2548     0x8CE5: 0x609F,
2549     0x8CE6: 0x68A7,
2550     0x8CE7: 0x6A8E,
2551     0x8CE8: 0x745A,
2552     0x8CE9: 0x7881,
2553     0x8CEA: 0x8A9E,
2554     0x8CEB: 0x8AA4,
2555     0x8CEC: 0x8B77,
2556     0x8CED: 0x9190,
2557     0x8CEE: 0x4E5E,
2558     0x8CEF: 0x9BC9,
2559     0x8CF0: 0x4EA4,
2560     0x8CF1: 0x4F7C,
2561     0x8CF2: 0x4FAF,
2562     0x8CF3: 0x5019,
2563     0x8CF4: 0x5016,
2564     0x8CF5: 0x5149,
2565     0x8CF6: 0x516C,
2566     0x8CF7: 0x529F,
2567     0x8CF8: 0x52B9,
2568     0x8CF9: 0x52FE,
2569     0x8CFA: 0x539A,
2570     0x8CFB: 0x53E3,
2571     0x8CFC: 0x5411,
2572     0x8D40: 0x540E,
2573     0x8D41: 0x5589,
2574     0x8D42: 0x5751,
2575     0x8D43: 0x57A2,
2576     0x8D44: 0x597D,
2577     0x8D45: 0x5B54,
2578     0x8D46: 0x5B5D,
2579     0x8D47: 0x5B8F,
2580     0x8D48: 0x5DE5,
2581     0x8D49: 0x5DE7,
2582     0x8D4A: 0x5DF7,
2583     0x8D4B: 0x5E78,
2584     0x8D4C: 0x5E83,
2585     0x8D4D: 0x5E9A,
2586     0x8D4E: 0x5EB7,
2587     0x8D4F: 0x5F18,
2588     0x8D50: 0x6052,
2589     0x8D51: 0x614C,
2590     0x8D52: 0x6297,
2591     0x8D53: 0x62D8,
2592     0x8D54: 0x63A7,
2593     0x8D55: 0x653B,
2594     0x8D56: 0x6602,
2595     0x8D57: 0x6643,
2596     0x8D58: 0x66F4,
2597     0x8D59: 0x676D,
2598     0x8D5A: 0x6821,
2599     0x8D5B: 0x6897,
2600     0x8D5C: 0x69CB,
2601     0x8D5D: 0x6C5F,
2602     0x8D5E: 0x6D2A,
2603     0x8D5F: 0x6D69,
2604     0x8D60: 0x6E2F,
2605     0x8D61: 0x6E9D,
2606     0x8D62: 0x7532,
2607     0x8D63: 0x7687,
2608     0x8D64: 0x786C,
2609     0x8D65: 0x7A3F,
2610     0x8D66: 0x7CE0,
2611     0x8D67: 0x7D05,
2612     0x8D68: 0x7D18,
2613     0x8D69: 0x7D5E,
2614     0x8D6A: 0x7DB1,
2615     0x8D6B: 0x8015,
2616     0x8D6C: 0x8003,
2617     0x8D6D: 0x80AF,
2618     0x8D6E: 0x80B1,
2619     0x8D6F: 0x8154,
2620     0x8D70: 0x818F,
2621     0x8D71: 0x822A,
2622     0x8D72: 0x8352,
2623     0x8D73: 0x884C,
2624     0x8D74: 0x8861,
2625     0x8D75: 0x8B1B,
2626     0x8D76: 0x8CA2,
2627     0x8D77: 0x8CFC,
2628     0x8D78: 0x90CA,
2629     0x8D79: 0x9175,
2630     0x8D7A: 0x9271,
2631     0x8D7B: 0x783F,
2632     0x8D7C: 0x92FC,
2633     0x8D7D: 0x95A4,
2634     0x8D7E: 0x964D,
2635     0x8D80: 0x9805,
2636     0x8D81: 0x9999,
2637     0x8D82: 0x9AD8,
2638     0x8D83: 0x9D3B,
2639     0x8D84: 0x525B,
2640     0x8D85: 0x52AB,
2641     0x8D86: 0x53F7,
2642     0x8D87: 0x5408,
2643     0x8D88: 0x58D5,
2644     0x8D89: 0x62F7,
2645     0x8D8A: 0x6FE0,
2646     0x8D8B: 0x8C6A,
2647     0x8D8C: 0x8F5F,
2648     0x8D8D: 0x9EB9,
2649     0x8D8E: 0x514B,
2650     0x8D8F: 0x523B,
2651     0x8D90: 0x544A,
2652     0x8D91: 0x56FD,
2653     0x8D92: 0x7A40,
2654     0x8D93: 0x9177,
2655     0x8D94: 0x9D60,
2656     0x8D95: 0x9ED2,
2657     0x8D96: 0x7344,
2658     0x8D97: 0x6F09,
2659     0x8D98: 0x8170,
2660     0x8D99: 0x7511,
2661     0x8D9A: 0x5FFD,
2662     0x8D9B: 0x60DA,
2663     0x8D9C: 0x9AA8,
2664     0x8D9D: 0x72DB,
2665     0x8D9E: 0x8FBC,
2666     0x8D9F: 0x6B64,
2667     0x8DA0: 0x9803,
2668     0x8DA1: 0x4ECA,
2669     0x8DA2: 0x56F0,
2670     0x8DA3: 0x5764,
2671     0x8DA4: 0x58BE,
2672     0x8DA5: 0x5A5A,
2673     0x8DA6: 0x6068,
2674     0x8DA7: 0x61C7,
2675     0x8DA8: 0x660F,
2676     0x8DA9: 0x6606,
2677     0x8DAA: 0x6839,
2678     0x8DAB: 0x68B1,
2679     0x8DAC: 0x6DF7,
2680     0x8DAD: 0x75D5,
2681     0x8DAE: 0x7D3A,
2682     0x8DAF: 0x826E,
2683     0x8DB0: 0x9B42,
2684     0x8DB1: 0x4E9B,
2685     0x8DB2: 0x4F50,
2686     0x8DB3: 0x53C9,
2687     0x8DB4: 0x5506,
2688     0x8DB5: 0x5D6F,
2689     0x8DB6: 0x5DE6,
2690     0x8DB7: 0x5DEE,
2691     0x8DB8: 0x67FB,
2692     0x8DB9: 0x6C99,
2693     0x8DBA: 0x7473,
2694     0x8DBB: 0x7802,
2695     0x8DBC: 0x8A50,
2696     0x8DBD: 0x9396,
2697     0x8DBE: 0x88DF,
2698     0x8DBF: 0x5750,
2699     0x8DC0: 0x5EA7,
2700     0x8DC1: 0x632B,
2701     0x8DC2: 0x50B5,
2702     0x8DC3: 0x50AC,
2703     0x8DC4: 0x518D,
2704     0x8DC5: 0x6700,
2705     0x8DC6: 0x54C9,
2706     0x8DC7: 0x585E,
2707     0x8DC8: 0x59BB,
2708     0x8DC9: 0x5BB0,
2709     0x8DCA: 0x5F69,
2710     0x8DCB: 0x624D,
2711     0x8DCC: 0x63A1,
2712     0x8DCD: 0x683D,
2713     0x8DCE: 0x6B73,
2714     0x8DCF: 0x6E08,
2715     0x8DD0: 0x707D,
2716     0x8DD1: 0x91C7,
2717     0x8DD2: 0x7280,
2718     0x8DD3: 0x7815,
2719     0x8DD4: 0x7826,
2720     0x8DD5: 0x796D,
2721     0x8DD6: 0x658E,
2722     0x8DD7: 0x7D30,
2723     0x8DD8: 0x83DC,
2724     0x8DD9: 0x88C1,
2725     0x8DDA: 0x8F09,
2726     0x8DDB: 0x969B,
2727     0x8DDC: 0x5264,
2728     0x8DDD: 0x5728,
2729     0x8DDE: 0x6750,
2730     0x8DDF: 0x7F6A,
2731     0x8DE0: 0x8CA1,
2732     0x8DE1: 0x51B4,
2733     0x8DE2: 0x5742,
2734     0x8DE3: 0x962A,
2735     0x8DE4: 0x583A,
2736     0x8DE5: 0x698A,
2737     0x8DE6: 0x80B4,
2738     0x8DE7: 0x54B2,
2739     0x8DE8: 0x5D0E,
2740     0x8DE9: 0x57FC,
2741     0x8DEA: 0x7895,
2742     0x8DEB: 0x9DFA,
2743     0x8DEC: 0x4F5C,
2744     0x8DED: 0x524A,
2745     0x8DEE: 0x548B,
2746     0x8DEF: 0x643E,
2747     0x8DF0: 0x6628,
2748     0x8DF1: 0x6714,
2749     0x8DF2: 0x67F5,
2750     0x8DF3: 0x7A84,
2751     0x8DF4: 0x7B56,
2752     0x8DF5: 0x7D22,
2753     0x8DF6: 0x932F,
2754     0x8DF7: 0x685C,
2755     0x8DF8: 0x9BAD,
2756     0x8DF9: 0x7B39,
2757     0x8DFA: 0x5319,
2758     0x8DFB: 0x518A,
2759     0x8DFC: 0x5237,
2760     0x8E40: 0x5BDF,
2761     0x8E41: 0x62F6,
2762     0x8E42: 0x64AE,
2763     0x8E43: 0x64E6,
2764     0x8E44: 0x672D,
2765     0x8E45: 0x6BBA,
2766     0x8E46: 0x85A9,
2767     0x8E47: 0x96D1,
2768     0x8E48: 0x7690,
2769     0x8E49: 0x9BD6,
2770     0x8E4A: 0x634C,
2771     0x8E4B: 0x9306,
2772     0x8E4C: 0x9BAB,
2773     0x8E4D: 0x76BF,
2774     0x8E4E: 0x6652,
2775     0x8E4F: 0x4E09,
2776     0x8E50: 0x5098,
2777     0x8E51: 0x53C2,
2778     0x8E52: 0x5C71,
2779     0x8E53: 0x60E8,
2780     0x8E54: 0x6492,
2781     0x8E55: 0x6563,
2782     0x8E56: 0x685F,
2783     0x8E57: 0x71E6,
2784     0x8E58: 0x73CA,
2785     0x8E59: 0x7523,
2786     0x8E5A: 0x7B97,
2787     0x8E5B: 0x7E82,
2788     0x8E5C: 0x8695,
2789     0x8E5D: 0x8B83,
2790     0x8E5E: 0x8CDB,
2791     0x8E5F: 0x9178,
2792     0x8E60: 0x9910,
2793     0x8E61: 0x65AC,
2794     0x8E62: 0x66AB,
2795     0x8E63: 0x6B8B,
2796     0x8E64: 0x4ED5,
2797     0x8E65: 0x4ED4,
2798     0x8E66: 0x4F3A,
2799     0x8E67: 0x4F7F,
2800     0x8E68: 0x523A,
2801     0x8E69: 0x53F8,
2802     0x8E6A: 0x53F2,
2803     0x8E6B: 0x55E3,
2804     0x8E6C: 0x56DB,
2805     0x8E6D: 0x58EB,
2806     0x8E6E: 0x59CB,
2807     0x8E6F: 0x59C9,
2808     0x8E70: 0x59FF,
2809     0x8E71: 0x5B50,
2810     0x8E72: 0x5C4D,
2811     0x8E73: 0x5E02,
2812     0x8E74: 0x5E2B,
2813     0x8E75: 0x5FD7,
2814     0x8E76: 0x601D,
2815     0x8E77: 0x6307,
2816     0x8E78: 0x652F,
2817     0x8E79: 0x5B5C,
2818     0x8E7A: 0x65AF,
2819     0x8E7B: 0x65BD,
2820     0x8E7C: 0x65E8,
2821     0x8E7D: 0x679D,
2822     0x8E7E: 0x6B62,
2823     0x8E80: 0x6B7B,
2824     0x8E81: 0x6C0F,
2825     0x8E82: 0x7345,
2826     0x8E83: 0x7949,
2827     0x8E84: 0x79C1,
2828     0x8E85: 0x7CF8,
2829     0x8E86: 0x7D19,
2830     0x8E87: 0x7D2B,
2831     0x8E88: 0x80A2,
2832     0x8E89: 0x8102,
2833     0x8E8A: 0x81F3,
2834     0x8E8B: 0x8996,
2835     0x8E8C: 0x8A5E,
2836     0x8E8D: 0x8A69,
2837     0x8E8E: 0x8A66,
2838     0x8E8F: 0x8A8C,
2839     0x8E90: 0x8AEE,
2840     0x8E91: 0x8CC7,
2841     0x8E92: 0x8CDC,
2842     0x8E93: 0x96CC,
2843     0x8E94: 0x98FC,
2844     0x8E95: 0x6B6F,
2845     0x8E96: 0x4E8B,
2846     0x8E97: 0x4F3C,
2847     0x8E98: 0x4F8D,
2848     0x8E99: 0x5150,
2849     0x8E9A: 0x5B57,
2850     0x8E9B: 0x5BFA,
2851     0x8E9C: 0x6148,
2852     0x8E9D: 0x6301,
2853     0x8E9E: 0x6642,
2854     0x8E9F: 0x6B21,
2855     0x8EA0: 0x6ECB,
2856     0x8EA1: 0x6CBB,
2857     0x8EA2: 0x723E,
2858     0x8EA3: 0x74BD,
2859     0x8EA4: 0x75D4,
2860     0x8EA5: 0x78C1,
2861     0x8EA6: 0x793A,
2862     0x8EA7: 0x800C,
2863     0x8EA8: 0x8033,
2864     0x8EA9: 0x81EA,
2865     0x8EAA: 0x8494,
2866     0x8EAB: 0x8F9E,
2867     0x8EAC: 0x6C50,
2868     0x8EAD: 0x9E7F,
2869     0x8EAE: 0x5F0F,
2870     0x8EAF: 0x8B58,
2871     0x8EB0: 0x9D2B,
2872     0x8EB1: 0x7AFA,
2873     0x8EB2: 0x8EF8,
2874     0x8EB3: 0x5B8D,
2875     0x8EB4: 0x96EB,
2876     0x8EB5: 0x4E03,
2877     0x8EB6: 0x53F1,
2878     0x8EB7: 0x57F7,
2879     0x8EB8: 0x5931,
2880     0x8EB9: 0x5AC9,
2881     0x8EBA: 0x5BA4,
2882     0x8EBB: 0x6089,
2883     0x8EBC: 0x6E7F,
2884     0x8EBD: 0x6F06,
2885     0x8EBE: 0x75BE,
2886     0x8EBF: 0x8CEA,
2887     0x8EC0: 0x5B9F,
2888     0x8EC1: 0x8500,
2889     0x8EC2: 0x7BE0,
2890     0x8EC3: 0x5072,
2891     0x8EC4: 0x67F4,
2892     0x8EC5: 0x829D,
2893     0x8EC6: 0x5C61,
2894     0x8EC7: 0x854A,
2895     0x8EC8: 0x7E1E,
2896     0x8EC9: 0x820E,
2897     0x8ECA: 0x5199,
2898     0x8ECB: 0x5C04,
2899     0x8ECC: 0x6368,
2900     0x8ECD: 0x8D66,
2901     0x8ECE: 0x659C,
2902     0x8ECF: 0x716E,
2903     0x8ED0: 0x793E,
2904     0x8ED1: 0x7D17,
2905     0x8ED2: 0x8005,
2906     0x8ED3: 0x8B1D,
2907     0x8ED4: 0x8ECA,
2908     0x8ED5: 0x906E,
2909     0x8ED6: 0x86C7,
2910     0x8ED7: 0x90AA,
2911     0x8ED8: 0x501F,
2912     0x8ED9: 0x52FA,
2913     0x8EDA: 0x5C3A,
2914     0x8EDB: 0x6753,
2915     0x8EDC: 0x707C,
2916     0x8EDD: 0x7235,
2917     0x8EDE: 0x914C,
2918     0x8EDF: 0x91C8,
2919     0x8EE0: 0x932B,
2920     0x8EE1: 0x82E5,
2921     0x8EE2: 0x5BC2,
2922     0x8EE3: 0x5F31,
2923     0x8EE4: 0x60F9,
2924     0x8EE5: 0x4E3B,
2925     0x8EE6: 0x53D6,
2926     0x8EE7: 0x5B88,
2927     0x8EE8: 0x624B,
2928     0x8EE9: 0x6731,
2929     0x8EEA: 0x6B8A,
2930     0x8EEB: 0x72E9,
2931     0x8EEC: 0x73E0,
2932     0x8EED: 0x7A2E,
2933     0x8EEE: 0x816B,
2934     0x8EEF: 0x8DA3,
2935     0x8EF0: 0x9152,
2936     0x8EF1: 0x9996,
2937     0x8EF2: 0x5112,
2938     0x8EF3: 0x53D7,
2939     0x8EF4: 0x546A,
2940     0x8EF5: 0x5BFF,
2941     0x8EF6: 0x6388,
2942     0x8EF7: 0x6A39,
2943     0x8EF8: 0x7DAC,
2944     0x8EF9: 0x9700,
2945     0x8EFA: 0x56DA,
2946     0x8EFB: 0x53CE,
2947     0x8EFC: 0x5468,
2948     0x8F40: 0x5B97,
2949     0x8F41: 0x5C31,
2950     0x8F42: 0x5DDE,
2951     0x8F43: 0x4FEE,
2952     0x8F44: 0x6101,
2953     0x8F45: 0x62FE,
2954     0x8F46: 0x6D32,
2955     0x8F47: 0x79C0,
2956     0x8F48: 0x79CB,
2957     0x8F49: 0x7D42,
2958     0x8F4A: 0x7E4D,
2959     0x8F4B: 0x7FD2,
2960     0x8F4C: 0x81ED,
2961     0x8F4D: 0x821F,
2962     0x8F4E: 0x8490,
2963     0x8F4F: 0x8846,
2964     0x8F50: 0x8972,
2965     0x8F51: 0x8B90,
2966     0x8F52: 0x8E74,
2967     0x8F53: 0x8F2F,
2968     0x8F54: 0x9031,
2969     0x8F55: 0x914B,
2970     0x8F56: 0x916C,
2971     0x8F57: 0x96C6,
2972     0x8F58: 0x919C,
2973     0x8F59: 0x4EC0,
2974     0x8F5A: 0x4F4F,
2975     0x8F5B: 0x5145,
2976     0x8F5C: 0x5341,
2977     0x8F5D: 0x5F93,
2978     0x8F5E: 0x620E,
2979     0x8F5F: 0x67D4,
2980     0x8F60: 0x6C41,
2981     0x8F61: 0x6E0B,
2982     0x8F62: 0x7363,
2983     0x8F63: 0x7E26,
2984     0x8F64: 0x91CD,
2985     0x8F65: 0x9283,
2986     0x8F66: 0x53D4,
2987     0x8F67: 0x5919,
2988     0x8F68: 0x5BBF,
2989     0x8F69: 0x6DD1,
2990     0x8F6A: 0x795D,
2991     0x8F6B: 0x7E2E,
2992     0x8F6C: 0x7C9B,
2993     0x8F6D: 0x587E,
2994     0x8F6E: 0x719F,
2995     0x8F6F: 0x51FA,
2996     0x8F70: 0x8853,
2997     0x8F71: 0x8FF0,
2998     0x8F72: 0x4FCA,
2999     0x8F73: 0x5CFB,
3000     0x8F74: 0x6625,
3001     0x8F75: 0x77AC,
3002     0x8F76: 0x7AE3,
3003     0x8F77: 0x821C,
3004     0x8F78: 0x99FF,
3005     0x8F79: 0x51C6,
3006     0x8F7A: 0x5FAA,
3007     0x8F7B: 0x65EC,
3008     0x8F7C: 0x696F,
3009     0x8F7D: 0x6B89,
3010     0x8F7E: 0x6DF3,
3011     0x8F80: 0x6E96,
3012     0x8F81: 0x6F64,
3013     0x8F82: 0x76FE,
3014     0x8F83: 0x7D14,
3015     0x8F84: 0x5DE1,
3016     0x8F85: 0x9075,
3017     0x8F86: 0x9187,
3018     0x8F87: 0x9806,
3019     0x8F88: 0x51E6,
3020     0x8F89: 0x521D,
3021     0x8F8A: 0x6240,
3022     0x8F8B: 0x6691,
3023     0x8F8C: 0x66D9,
3024     0x8F8D: 0x6E1A,
3025     0x8F8E: 0x5EB6,
3026     0x8F8F: 0x7DD2,
3027     0x8F90: 0x7F72,
3028     0x8F91: 0x66F8,
3029     0x8F92: 0x85AF,
3030     0x8F93: 0x85F7,
3031     0x8F94: 0x8AF8,
3032     0x8F95: 0x52A9,
3033     0x8F96: 0x53D9,
3034     0x8F97: 0x5973,
3035     0x8F98: 0x5E8F,
3036     0x8F99: 0x5F90,
3037     0x8F9A: 0x6055,
3038     0x8F9B: 0x92E4,
3039     0x8F9C: 0x9664,
3040     0x8F9D: 0x50B7,
3041     0x8F9E: 0x511F,
3042     0x8F9F: 0x52DD,
3043     0x8FA0: 0x5320,
3044     0x8FA1: 0x5347,
3045     0x8FA2: 0x53EC,
3046     0x8FA3: 0x54E8,
3047     0x8FA4: 0x5546,
3048     0x8FA5: 0x5531,
3049     0x8FA6: 0x5617,
3050     0x8FA7: 0x5968,
3051     0x8FA8: 0x59BE,
3052     0x8FA9: 0x5A3C,
3053     0x8FAA: 0x5BB5,
3054     0x8FAB: 0x5C06,
3055     0x8FAC: 0x5C0F,
3056     0x8FAD: 0x5C11,
3057     0x8FAE: 0x5C1A,
3058     0x8FAF: 0x5E84,
3059     0x8FB0: 0x5E8A,
3060     0x8FB1: 0x5EE0,
3061     0x8FB2: 0x5F70,
3062     0x8FB3: 0x627F,
3063     0x8FB4: 0x6284,
3064     0x8FB5: 0x62DB,
3065     0x8FB6: 0x638C,
3066     0x8FB7: 0x6377,
3067     0x8FB8: 0x6607,
3068     0x8FB9: 0x660C,
3069     0x8FBA: 0x662D,
3070     0x8FBB: 0x6676,
3071     0x8FBC: 0x677E,
3072     0x8FBD: 0x68A2,
3073     0x8FBE: 0x6A1F,
3074     0x8FBF: 0x6A35,
3075     0x8FC0: 0x6CBC,
3076     0x8FC1: 0x6D88,
3077     0x8FC2: 0x6E09,
3078     0x8FC3: 0x6E58,
3079     0x8FC4: 0x713C,
3080     0x8FC5: 0x7126,
3081     0x8FC6: 0x7167,
3082     0x8FC7: 0x75C7,
3083     0x8FC8: 0x7701,
3084     0x8FC9: 0x785D,
3085     0x8FCA: 0x7901,
3086     0x8FCB: 0x7965,
3087     0x8FCC: 0x79F0,
3088     0x8FCD: 0x7AE0,
3089     0x8FCE: 0x7B11,
3090     0x8FCF: 0x7CA7,
3091     0x8FD0: 0x7D39,
3092     0x8FD1: 0x8096,
3093     0x8FD2: 0x83D6,
3094     0x8FD3: 0x848B,
3095     0x8FD4: 0x8549,
3096     0x8FD5: 0x885D,
3097     0x8FD6: 0x88F3,
3098     0x8FD7: 0x8A1F,
3099     0x8FD8: 0x8A3C,
3100     0x8FD9: 0x8A54,
3101     0x8FDA: 0x8A73,
3102     0x8FDB: 0x8C61,
3103     0x8FDC: 0x8CDE,
3104     0x8FDD: 0x91A4,
3105     0x8FDE: 0x9266,
3106     0x8FDF: 0x937E,
3107     0x8FE0: 0x9418,
3108     0x8FE1: 0x969C,
3109     0x8FE2: 0x9798,
3110     0x8FE3: 0x4E0A,
3111     0x8FE4: 0x4E08,
3112     0x8FE5: 0x4E1E,
3113     0x8FE6: 0x4E57,
3114     0x8FE7: 0x5197,
3115     0x8FE8: 0x5270,
3116     0x8FE9: 0x57CE,
3117     0x8FEA: 0x5834,
3118     0x8FEB: 0x58CC,
3119     0x8FEC: 0x5B22,
3120     0x8FED: 0x5E38,
3121     0x8FEE: 0x60C5,
3122     0x8FEF: 0x64FE,
3123     0x8FF0: 0x6761,
3124     0x8FF1: 0x6756,
3125     0x8FF2: 0x6D44,
3126     0x8FF3: 0x72B6,
3127     0x8FF4: 0x7573,
3128     0x8FF5: 0x7A63,
3129     0x8FF6: 0x84B8,
3130     0x8FF7: 0x8B72,
3131     0x8FF8: 0x91B8,
3132     0x8FF9: 0x9320,
3133     0x8FFA: 0x5631,
3134     0x8FFB: 0x57F4,
3135     0x8FFC: 0x98FE,
3136     0x9040: 0x62ED,
3137     0x9041: 0x690D,
3138     0x9042: 0x6B96,
3139     0x9043: 0x71ED,
3140     0x9044: 0x7E54,
3141     0x9045: 0x8077,
3142     0x9046: 0x8272,
3143     0x9047: 0x89E6,
3144     0x9048: 0x98DF,
3145     0x9049: 0x8755,
3146     0x904A: 0x8FB1,
3147     0x904B: 0x5C3B,
3148     0x904C: 0x4F38,
3149     0x904D: 0x4FE1,
3150     0x904E: 0x4FB5,
3151     0x904F: 0x5507,
3152     0x9050: 0x5A20,
3153     0x9051: 0x5BDD,
3154     0x9052: 0x5BE9,
3155     0x9053: 0x5FC3,
3156     0x9054: 0x614E,
3157     0x9055: 0x632F,
3158     0x9056: 0x65B0,
3159     0x9057: 0x664B,
3160     0x9058: 0x68EE,
3161     0x9059: 0x699B,
3162     0x905A: 0x6D78,
3163     0x905B: 0x6DF1,
3164     0x905C: 0x7533,
3165     0x905D: 0x75B9,
3166     0x905E: 0x771F,
3167     0x905F: 0x795E,
3168     0x9060: 0x79E6,
3169     0x9061: 0x7D33,
3170     0x9062: 0x81E3,
3171     0x9063: 0x82AF,
3172     0x9064: 0x85AA,
3173     0x9065: 0x89AA,
3174     0x9066: 0x8A3A,
3175     0x9067: 0x8EAB,
3176     0x9068: 0x8F9B,
3177     0x9069: 0x9032,
3178     0x906A: 0x91DD,
3179     0x906B: 0x9707,
3180     0x906C: 0x4EBA,
3181     0x906D: 0x4EC1,
3182     0x906E: 0x5203,
3183     0x906F: 0x5875,
3184     0x9070: 0x58EC,
3185     0x9071: 0x5C0B,
3186     0x9072: 0x751A,
3187     0x9073: 0x5C3D,
3188     0x9074: 0x814E,
3189     0x9075: 0x8A0A,
3190     0x9076: 0x8FC5,
3191     0x9077: 0x9663,
3192     0x9078: 0x976D,
3193     0x9079: 0x7B25,
3194     0x907A: 0x8ACF,
3195     0x907B: 0x9808,
3196     0x907C: 0x9162,
3197     0x907D: 0x56F3,
3198     0x907E: 0x53A8,
3199     0x9080: 0x9017,
3200     0x9081: 0x5439,
3201     0x9082: 0x5782,
3202     0x9083: 0x5E25,
3203     0x9084: 0x63A8,
3204     0x9085: 0x6C34,
3205     0x9086: 0x708A,
3206     0x9087: 0x7761,
3207     0x9088: 0x7C8B,
3208     0x9089: 0x7FE0,
3209     0x908A: 0x8870,
3210     0x908B: 0x9042,
3211     0x908C: 0x9154,
3212     0x908D: 0x9310,
3213     0x908E: 0x9318,
3214     0x908F: 0x968F,
3215     0x9090: 0x745E,
3216     0x9091: 0x9AC4,
3217     0x9092: 0x5D07,
3218     0x9093: 0x5D69,
3219     0x9094: 0x6570,
3220     0x9095: 0x67A2,
3221     0x9096: 0x8DA8,
3222     0x9097: 0x96DB,
3223     0x9098: 0x636E,
3224     0x9099: 0x6749,
3225     0x909A: 0x6919,
3226     0x909B: 0x83C5,
3227     0x909C: 0x9817,
3228     0x909D: 0x96C0,
3229     0x909E: 0x88FE,
3230     0x909F: 0x6F84,
3231     0x90A0: 0x647A,
3232     0x90A1: 0x5BF8,
3233     0x90A2: 0x4E16,
3234     0x90A3: 0x702C,
3235     0x90A4: 0x755D,
3236     0x90A5: 0x662F,
3237     0x90A6: 0x51C4,
3238     0x90A7: 0x5236,
3239     0x90A8: 0x52E2,
3240     0x90A9: 0x59D3,
3241     0x90AA: 0x5F81,
3242     0x90AB: 0x6027,
3243     0x90AC: 0x6210,
3244     0x90AD: 0x653F,
3245     0x90AE: 0x6574,
3246     0x90AF: 0x661F,
3247     0x90B0: 0x6674,
3248     0x90B1: 0x68F2,
3249     0x90B2: 0x6816,
3250     0x90B3: 0x6B63,
3251     0x90B4: 0x6E05,
3252     0x90B5: 0x7272,
3253     0x90B6: 0x751F,
3254     0x90B7: 0x76DB,
3255     0x90B8: 0x7CBE,
3256     0x90B9: 0x8056,
3257     0x90BA: 0x58F0,
3258     0x90BB: 0x88FD,
3259     0x90BC: 0x897F,
3260     0x90BD: 0x8AA0,
3261     0x90BE: 0x8A93,
3262     0x90BF: 0x8ACB,
3263     0x90C0: 0x901D,
3264     0x90C1: 0x9192,
3265     0x90C2: 0x9752,
3266     0x90C3: 0x9759,
3267     0x90C4: 0x6589,
3268     0x90C5: 0x7A0E,
3269     0x90C6: 0x8106,
3270     0x90C7: 0x96BB,
3271     0x90C8: 0x5E2D,
3272     0x90C9: 0x60DC,
3273     0x90CA: 0x621A,
3274     0x90CB: 0x65A5,
3275     0x90CC: 0x6614,
3276     0x90CD: 0x6790,
3277     0x90CE: 0x77F3,
3278     0x90CF: 0x7A4D,
3279     0x90D0: 0x7C4D,
3280     0x90D1: 0x7E3E,
3281     0x90D2: 0x810A,
3282     0x90D3: 0x8CAC,
3283     0x90D4: 0x8D64,
3284     0x90D5: 0x8DE1,
3285     0x90D6: 0x8E5F,
3286     0x90D7: 0x78A9,
3287     0x90D8: 0x5207,
3288     0x90D9: 0x62D9,
3289     0x90DA: 0x63A5,
3290     0x90DB: 0x6442,
3291     0x90DC: 0x6298,
3292     0x90DD: 0x8A2D,
3293     0x90DE: 0x7A83,
3294     0x90DF: 0x7BC0,
3295     0x90E0: 0x8AAC,
3296     0x90E1: 0x96EA,
3297     0x90E2: 0x7D76,
3298     0x90E3: 0x820C,
3299     0x90E4: 0x8749,
3300     0x90E5: 0x4ED9,
3301     0x90E6: 0x5148,
3302     0x90E7: 0x5343,
3303     0x90E8: 0x5360,
3304     0x90E9: 0x5BA3,
3305     0x90EA: 0x5C02,
3306     0x90EB: 0x5C16,
3307     0x90EC: 0x5DDD,
3308     0x90ED: 0x6226,
3309     0x90EE: 0x6247,
3310     0x90EF: 0x64B0,
3311     0x90F0: 0x6813,
3312     0x90F1: 0x6834,
3313     0x90F2: 0x6CC9,
3314     0x90F3: 0x6D45,
3315     0x90F4: 0x6D17,
3316     0x90F5: 0x67D3,
3317     0x90F6: 0x6F5C,
3318     0x90F7: 0x714E,
3319     0x90F8: 0x717D,
3320     0x90F9: 0x65CB,
3321     0x90FA: 0x7A7F,
3322     0x90FB: 0x7BAD,
3323     0x90FC: 0x7DDA,
3324     0x9140: 0x7E4A,
3325     0x9141: 0x7FA8,
3326     0x9142: 0x817A,
3327     0x9143: 0x821B,
3328     0x9144: 0x8239,
3329     0x9145: 0x85A6,
3330     0x9146: 0x8A6E,
3331     0x9147: 0x8CCE,
3332     0x9148: 0x8DF5,
3333     0x9149: 0x9078,
3334     0x914A: 0x9077,
3335     0x914B: 0x92AD,
3336     0x914C: 0x9291,
3337     0x914D: 0x9583,
3338     0x914E: 0x9BAE,
3339     0x914F: 0x524D,
3340     0x9150: 0x5584,
3341     0x9151: 0x6F38,
3342     0x9152: 0x7136,
3343     0x9153: 0x5168,
3344     0x9154: 0x7985,
3345     0x9155: 0x7E55,
3346     0x9156: 0x81B3,
3347     0x9157: 0x7CCE,
3348     0x9158: 0x564C,
3349     0x9159: 0x5851,
3350     0x915A: 0x5CA8,
3351     0x915B: 0x63AA,
3352     0x915C: 0x66FE,
3353     0x915D: 0x66FD,
3354     0x915E: 0x695A,
3355     0x915F: 0x72D9,
3356     0x9160: 0x758F,
3357     0x9161: 0x758E,
3358     0x9162: 0x790E,
3359     0x9163: 0x7956,
3360     0x9164: 0x79DF,
3361     0x9165: 0x7C97,
3362     0x9166: 0x7D20,
3363     0x9167: 0x7D44,
3364     0x9168: 0x8607,
3365     0x9169: 0x8A34,
3366     0x916A: 0x963B,
3367     0x916B: 0x9061,
3368     0x916C: 0x9F20,
3369     0x916D: 0x50E7,
3370     0x916E: 0x5275,
3371     0x916F: 0x53CC,
3372     0x9170: 0x53E2,
3373     0x9171: 0x5009,
3374     0x9172: 0x55AA,
3375     0x9173: 0x58EE,
3376     0x9174: 0x594F,
3377     0x9175: 0x723D,
3378     0x9176: 0x5B8B,
3379     0x9177: 0x5C64,
3380     0x9178: 0x531D,
3381     0x9179: 0x60E3,
3382     0x917A: 0x60F3,
3383     0x917B: 0x635C,
3384     0x917C: 0x6383,
3385     0x917D: 0x633F,
3386     0x917E: 0x63BB,
3387     0x9180: 0x64CD,
3388     0x9181: 0x65E9,
3389     0x9182: 0x66F9,
3390     0x9183: 0x5DE3,
3391     0x9184: 0x69CD,
3392     0x9185: 0x69FD,
3393     0x9186: 0x6F15,
3394     0x9187: 0x71E5,
3395     0x9188: 0x4E89,
3396     0x9189: 0x75E9,
3397     0x918A: 0x76F8,
3398     0x918B: 0x7A93,
3399     0x918C: 0x7CDF,
3400     0x918D: 0x7DCF,
3401     0x918E: 0x7D9C,
3402     0x918F: 0x8061,
3403     0x9190: 0x8349,
3404     0x9191: 0x8358,
3405     0x9192: 0x846C,
3406     0x9193: 0x84BC,
3407     0x9194: 0x85FB,
3408     0x9195: 0x88C5,
3409     0x9196: 0x8D70,
3410     0x9197: 0x9001,
3411     0x9198: 0x906D,
3412     0x9199: 0x9397,
3413     0x919A: 0x971C,
3414     0x919B: 0x9A12,
3415     0x919C: 0x50CF,
3416     0x919D: 0x5897,
3417     0x919E: 0x618E,
3418     0x919F: 0x81D3,
3419     0x91A0: 0x8535,
3420     0x91A1: 0x8D08,
3421     0x91A2: 0x9020,
3422     0x91A3: 0x4FC3,
3423     0x91A4: 0x5074,
3424     0x91A5: 0x5247,
3425     0x91A6: 0x5373,
3426     0x91A7: 0x606F,
3427     0x91A8: 0x6349,
3428     0x91A9: 0x675F,
3429     0x91AA: 0x6E2C,
3430     0x91AB: 0x8DB3,
3431     0x91AC: 0x901F,
3432     0x91AD: 0x4FD7,
3433     0x91AE: 0x5C5E,
3434     0x91AF: 0x8CCA,
3435     0x91B0: 0x65CF,
3436     0x91B1: 0x7D9A,
3437     0x91B2: 0x5352,
3438     0x91B3: 0x8896,
3439     0x91B4: 0x5176,
3440     0x91B5: 0x63C3,
3441     0x91B6: 0x5B58,
3442     0x91B7: 0x5B6B,
3443     0x91B8: 0x5C0A,
3444     0x91B9: 0x640D,
3445     0x91BA: 0x6751,
3446     0x91BB: 0x905C,
3447     0x91BC: 0x4ED6,
3448     0x91BD: 0x591A,
3449     0x91BE: 0x592A,
3450     0x91BF: 0x6C70,
3451     0x91C0: 0x8A51,
3452     0x91C1: 0x553E,
3453     0x91C2: 0x5815,
3454     0x91C3: 0x59A5,
3455     0x91C4: 0x60F0,
3456     0x91C5: 0x6253,
3457     0x91C6: 0x67C1,
3458     0x91C7: 0x8235,
3459     0x91C8: 0x6955,
3460     0x91C9: 0x9640,
3461     0x91CA: 0x99C4,
3462     0x91CB: 0x9A28,
3463     0x91CC: 0x4F53,
3464     0x91CD: 0x5806,
3465     0x91CE: 0x5BFE,
3466     0x91CF: 0x8010,
3467     0x91D0: 0x5CB1,
3468     0x91D1: 0x5E2F,
3469     0x91D2: 0x5F85,
3470     0x91D3: 0x6020,
3471     0x91D4: 0x614B,
3472     0x91D5: 0x6234,
3473     0x91D6: 0x66FF,
3474     0x91D7: 0x6CF0,
3475     0x91D8: 0x6EDE,
3476     0x91D9: 0x80CE,
3477     0x91DA: 0x817F,
3478     0x91DB: 0x82D4,
3479     0x91DC: 0x888B,
3480     0x91DD: 0x8CB8,
3481     0x91DE: 0x9000,
3482     0x91DF: 0x902E,
3483     0x91E0: 0x968A,
3484     0x91E1: 0x9EDB,
3485     0x91E2: 0x9BDB,
3486     0x91E3: 0x4EE3,
3487     0x91E4: 0x53F0,
3488     0x91E5: 0x5927,
3489     0x91E6: 0x7B2C,
3490     0x91E7: 0x918D,
3491     0x91E8: 0x984C,
3492     0x91E9: 0x9DF9,
3493     0x91EA: 0x6EDD,
3494     0x91EB: 0x7027,
3495     0x91EC: 0x5353,
3496     0x91ED: 0x5544,
3497     0x91EE: 0x5B85,
3498     0x91EF: 0x6258,
3499     0x91F0: 0x629E,
3500     0x91F1: 0x62D3,
3501     0x91F2: 0x6CA2,
3502     0x91F3: 0x6FEF,
3503     0x91F4: 0x7422,
3504     0x91F5: 0x8A17,
3505     0x91F6: 0x9438,
3506     0x91F7: 0x6FC1,
3507     0x91F8: 0x8AFE,
3508     0x91F9: 0x8338,
3509     0x91FA: 0x51E7,
3510     0x91FB: 0x86F8,
3511     0x91FC: 0x53EA,
3512     0x9240: 0x53E9,
3513     0x9241: 0x4F46,
3514     0x9242: 0x9054,
3515     0x9243: 0x8FB0,
3516     0x9244: 0x596A,
3517     0x9245: 0x8131,
3518     0x9246: 0x5DFD,
3519     0x9247: 0x7AEA,
3520     0x9248: 0x8FBF,
3521     0x9249: 0x68DA,
3522     0x924A: 0x8C37,
3523     0x924B: 0x72F8,
3524     0x924C: 0x9C48,
3525     0x924D: 0x6A3D,
3526     0x924E: 0x8AB0,
3527     0x924F: 0x4E39,
3528     0x9250: 0x5358,
3529     0x9251: 0x5606,
3530     0x9252: 0x5766,
3531     0x9253: 0x62C5,
3532     0x9254: 0x63A2,
3533     0x9255: 0x65E6,
3534     0x9256: 0x6B4E,
3535     0x9257: 0x6DE1,
3536     0x9258: 0x6E5B,
3537     0x9259: 0x70AD,
3538     0x925A: 0x77ED,
3539     0x925B: 0x7AEF,
3540     0x925C: 0x7BAA,
3541     0x925D: 0x7DBB,
3542     0x925E: 0x803D,
3543     0x925F: 0x80C6,
3544     0x9260: 0x86CB,
3545     0x9261: 0x8A95,
3546     0x9262: 0x935B,
3547     0x9263: 0x56E3,
3548     0x9264: 0x58C7,
3549     0x9265: 0x5F3E,
3550     0x9266: 0x65AD,
3551     0x9267: 0x6696,
3552     0x9268: 0x6A80,
3553     0x9269: 0x6BB5,
3554     0x926A: 0x7537,
3555     0x926B: 0x8AC7,
3556     0x926C: 0x5024,
3557     0x926D: 0x77E5,
3558     0x926E: 0x5730,
3559     0x926F: 0x5F1B,
3560     0x9270: 0x6065,
3561     0x9271: 0x667A,
3562     0x9272: 0x6C60,
3563     0x9273: 0x75F4,
3564     0x9274: 0x7A1A,
3565     0x9275: 0x7F6E,
3566     0x9276: 0x81F4,
3567     0x9277: 0x8718,
3568     0x9278: 0x9045,
3569     0x9279: 0x99B3,
3570     0x927A: 0x7BC9,
3571     0x927B: 0x755C,
3572     0x927C: 0x7AF9,
3573     0x927D: 0x7B51,
3574     0x927E: 0x84C4,
3575     0x9280: 0x9010,
3576     0x9281: 0x79E9,
3577     0x9282: 0x7A92,
3578     0x9283: 0x8336,
3579     0x9284: 0x5AE1,
3580     0x9285: 0x7740,
3581     0x9286: 0x4E2D,
3582     0x9287: 0x4EF2,
3583     0x9288: 0x5B99,
3584     0x9289: 0x5FE0,
3585     0x928A: 0x62BD,
3586     0x928B: 0x663C,
3587     0x928C: 0x67F1,
3588     0x928D: 0x6CE8,
3589     0x928E: 0x866B,
3590     0x928F: 0x8877,
3591     0x9290: 0x8A3B,
3592     0x9291: 0x914E,
3593     0x9292: 0x92F3,
3594     0x9293: 0x99D0,
3595     0x9294: 0x6A17,
3596     0x9295: 0x7026,
3597     0x9296: 0x732A,
3598     0x9297: 0x82E7,
3599     0x9298: 0x8457,
3600     0x9299: 0x8CAF,
3601     0x929A: 0x4E01,
3602     0x929B: 0x5146,
3603     0x929C: 0x51CB,
3604     0x929D: 0x558B,
3605     0x929E: 0x5BF5,
3606     0x929F: 0x5E16,
3607     0x92A0: 0x5E33,
3608     0x92A1: 0x5E81,
3609     0x92A2: 0x5F14,
3610     0x92A3: 0x5F35,
3611     0x92A4: 0x5F6B,
3612     0x92A5: 0x5FB4,
3613     0x92A6: 0x61F2,
3614     0x92A7: 0x6311,
3615     0x92A8: 0x66A2,
3616     0x92A9: 0x671D,
3617     0x92AA: 0x6F6E,
3618     0x92AB: 0x7252,
3619     0x92AC: 0x753A,
3620     0x92AD: 0x773A,
3621     0x92AE: 0x8074,
3622     0x92AF: 0x8139,
3623     0x92B0: 0x8178,
3624     0x92B1: 0x8776,
3625     0x92B2: 0x8ABF,
3626     0x92B3: 0x8ADC,
3627     0x92B4: 0x8D85,
3628     0x92B5: 0x8DF3,
3629     0x92B6: 0x929A,
3630     0x92B7: 0x9577,
3631     0x92B8: 0x9802,
3632     0x92B9: 0x9CE5,
3633     0x92BA: 0x52C5,
3634     0x92BB: 0x6357,
3635     0x92BC: 0x76F4,
3636     0x92BD: 0x6715,
3637     0x92BE: 0x6C88,
3638     0x92BF: 0x73CD,
3639     0x92C0: 0x8CC3,
3640     0x92C1: 0x93AE,
3641     0x92C2: 0x9673,
3642     0x92C3: 0x6D25,
3643     0x92C4: 0x589C,
3644     0x92C5: 0x690E,
3645     0x92C6: 0x69CC,
3646     0x92C7: 0x8FFD,
3647     0x92C8: 0x939A,
3648     0x92C9: 0x75DB,
3649     0x92CA: 0x901A,
3650     0x92CB: 0x585A,
3651     0x92CC: 0x6802,
3652     0x92CD: 0x63B4,
3653     0x92CE: 0x69FB,
3654     0x92CF: 0x4F43,
3655     0x92D0: 0x6F2C,
3656     0x92D1: 0x67D8,
3657     0x92D2: 0x8FBB,
3658     0x92D3: 0x8526,
3659     0x92D4: 0x7DB4,
3660     0x92D5: 0x9354,
3661     0x92D6: 0x693F,
3662     0x92D7: 0x6F70,
3663     0x92D8: 0x576A,
3664     0x92D9: 0x58F7,
3665     0x92DA: 0x5B2C,
3666     0x92DB: 0x7D2C,
3667     0x92DC: 0x722A,
3668     0x92DD: 0x540A,
3669     0x92DE: 0x91E3,
3670     0x92DF: 0x9DB4,
3671     0x92E0: 0x4EAD,
3672     0x92E1: 0x4F4E,
3673     0x92E2: 0x505C,
3674     0x92E3: 0x5075,
3675     0x92E4: 0x5243,
3676     0x92E5: 0x8C9E,
3677     0x92E6: 0x5448,
3678     0x92E7: 0x5824,
3679     0x92E8: 0x5B9A,
3680     0x92E9: 0x5E1D,
3681     0x92EA: 0x5E95,
3682     0x92EB: 0x5EAD,
3683     0x92EC: 0x5EF7,
3684     0x92ED: 0x5F1F,
3685     0x92EE: 0x608C,
3686     0x92EF: 0x62B5,
3687     0x92F0: 0x633A,
3688     0x92F1: 0x63D0,
3689     0x92F2: 0x68AF,
3690     0x92F3: 0x6C40,
3691     0x92F4: 0x7887,
3692     0x92F5: 0x798E,
3693     0x92F6: 0x7A0B,
3694     0x92F7: 0x7DE0,
3695     0x92F8: 0x8247,
3696     0x92F9: 0x8A02,
3697     0x92FA: 0x8AE6,
3698     0x92FB: 0x8E44,
3699     0x92FC: 0x9013,
3700     0x9340: 0x90B8,
3701     0x9341: 0x912D,
3702     0x9342: 0x91D8,
3703     0x9343: 0x9F0E,
3704     0x9344: 0x6CE5,
3705     0x9345: 0x6458,
3706     0x9346: 0x64E2,
3707     0x9347: 0x6575,
3708     0x9348: 0x6EF4,
3709     0x9349: 0x7684,
3710     0x934A: 0x7B1B,
3711     0x934B: 0x9069,
3712     0x934C: 0x93D1,
3713     0x934D: 0x6EBA,
3714     0x934E: 0x54F2,
3715     0x934F: 0x5FB9,
3716     0x9350: 0x64A4,
3717     0x9351: 0x8F4D,
3718     0x9352: 0x8FED,
3719     0x9353: 0x9244,
3720     0x9354: 0x5178,
3721     0x9355: 0x586B,
3722     0x9356: 0x5929,
3723     0x9357: 0x5C55,
3724     0x9358: 0x5E97,
3725     0x9359: 0x6DFB,
3726     0x935A: 0x7E8F,
3727     0x935B: 0x751C,
3728     0x935C: 0x8CBC,
3729     0x935D: 0x8EE2,
3730     0x935E: 0x985B,
3731     0x935F: 0x70B9,
3732     0x9360: 0x4F1D,
3733     0x9361: 0x6BBF,
3734     0x9362: 0x6FB1,
3735     0x9363: 0x7530,
3736     0x9364: 0x96FB,
3737     0x9365: 0x514E,
3738     0x9366: 0x5410,
3739     0x9367: 0x5835,
3740     0x9368: 0x5857,
3741     0x9369: 0x59AC,
3742     0x936A: 0x5C60,
3743     0x936B: 0x5F92,
3744     0x936C: 0x6597,
3745     0x936D: 0x675C,
3746     0x936E: 0x6E21,
3747     0x936F: 0x767B,
3748     0x9370: 0x83DF,
3749     0x9371: 0x8CED,
3750     0x9372: 0x9014,
3751     0x9373: 0x90FD,
3752     0x9374: 0x934D,
3753     0x9375: 0x7825,
3754     0x9376: 0x783A,
3755     0x9377: 0x52AA,
3756     0x9378: 0x5EA6,
3757     0x9379: 0x571F,
3758     0x937A: 0x5974,
3759     0x937B: 0x6012,
3760     0x937C: 0x5012,
3761     0x937D: 0x515A,
3762     0x937E: 0x51AC,
3763     0x9380: 0x51CD,
3764     0x9381: 0x5200,
3765     0x9382: 0x5510,
3766     0x9383: 0x5854,
3767     0x9384: 0x5858,
3768     0x9385: 0x5957,
3769     0x9386: 0x5B95,
3770     0x9387: 0x5CF6,
3771     0x9388: 0x5D8B,
3772     0x9389: 0x60BC,
3773     0x938A: 0x6295,
3774     0x938B: 0x642D,
3775     0x938C: 0x6771,
3776     0x938D: 0x6843,
3777     0x938E: 0x68BC,
3778     0x938F: 0x68DF,
3779     0x9390: 0x76D7,
3780     0x9391: 0x6DD8,
3781     0x9392: 0x6E6F,
3782     0x9393: 0x6D9B,
3783     0x9394: 0x706F,
3784     0x9395: 0x71C8,
3785     0x9396: 0x5F53,
3786     0x9397: 0x75D8,
3787     0x9398: 0x7977,
3788     0x9399: 0x7B49,
3789     0x939A: 0x7B54,
3790     0x939B: 0x7B52,
3791     0x939C: 0x7CD6,
3792     0x939D: 0x7D71,
3793     0x939E: 0x5230,
3794     0x939F: 0x8463,
3795     0x93A0: 0x8569,
3796     0x93A1: 0x85E4,
3797     0x93A2: 0x8A0E,
3798     0x93A3: 0x8B04,
3799     0x93A4: 0x8C46,
3800     0x93A5: 0x8E0F,
3801     0x93A6: 0x9003,
3802     0x93A7: 0x900F,
3803     0x93A8: 0x9419,
3804     0x93A9: 0x9676,
3805     0x93AA: 0x982D,
3806     0x93AB: 0x9A30,
3807     0x93AC: 0x95D8,
3808     0x93AD: 0x50CD,
3809     0x93AE: 0x52D5,
3810     0x93AF: 0x540C,
3811     0x93B0: 0x5802,
3812     0x93B1: 0x5C0E,
3813     0x93B2: 0x61A7,
3814     0x93B3: 0x649E,
3815     0x93B4: 0x6D1E,
3816     0x93B5: 0x77B3,
3817     0x93B6: 0x7AE5,
3818     0x93B7: 0x80F4,
3819     0x93B8: 0x8404,
3820     0x93B9: 0x9053,
3821     0x93BA: 0x9285,
3822     0x93BB: 0x5CE0,
3823     0x93BC: 0x9D07,
3824     0x93BD: 0x533F,
3825     0x93BE: 0x5F97,
3826     0x93BF: 0x5FB3,
3827     0x93C0: 0x6D9C,
3828     0x93C1: 0x7279,
3829     0x93C2: 0x7763,
3830     0x93C3: 0x79BF,
3831     0x93C4: 0x7BE4,
3832     0x93C5: 0x6BD2,
3833     0x93C6: 0x72EC,
3834     0x93C7: 0x8AAD,
3835     0x93C8: 0x6803,
3836     0x93C9: 0x6A61,
3837     0x93CA: 0x51F8,
3838     0x93CB: 0x7A81,
3839     0x93CC: 0x6934,
3840     0x93CD: 0x5C4A,
3841     0x93CE: 0x9CF6,
3842     0x93CF: 0x82EB,
3843     0x93D0: 0x5BC5,
3844     0x93D1: 0x9149,
3845     0x93D2: 0x701E,
3846     0x93D3: 0x5678,
3847     0x93D4: 0x5C6F,
3848     0x93D5: 0x60C7,
3849     0x93D6: 0x6566,
3850     0x93D7: 0x6C8C,
3851     0x93D8: 0x8C5A,
3852     0x93D9: 0x9041,
3853     0x93DA: 0x9813,
3854     0x93DB: 0x5451,
3855     0x93DC: 0x66C7,
3856     0x93DD: 0x920D,
3857     0x93DE: 0x5948,
3858     0x93DF: 0x90A3,
3859     0x93E0: 0x5185,
3860     0x93E1: 0x4E4D,
3861     0x93E2: 0x51EA,
3862     0x93E3: 0x8599,
3863     0x93E4: 0x8B0E,
3864     0x93E5: 0x7058,
3865     0x93E6: 0x637A,
3866     0x93E7: 0x934B,
3867     0x93E8: 0x6962,
3868     0x93E9: 0x99B4,
3869     0x93EA: 0x7E04,
3870     0x93EB: 0x7577,
3871     0x93EC: 0x5357,
3872     0x93ED: 0x6960,
3873     0x93EE: 0x8EDF,
3874     0x93EF: 0x96E3,
3875     0x93F0: 0x6C5D,
3876     0x93F1: 0x4E8C,
3877     0x93F2: 0x5C3C,
3878     0x93F3: 0x5F10,
3879     0x93F4: 0x8FE9,
3880     0x93F5: 0x5302,
3881     0x93F6: 0x8CD1,
3882     0x93F7: 0x8089,
3883     0x93F8: 0x8679,
3884     0x93F9: 0x5EFF,
3885     0x93FA: 0x65E5,
3886     0x93FB: 0x4E73,
3887     0x93FC: 0x5165,
3888     0x9440: 0x5982,
3889     0x9441: 0x5C3F,
3890     0x9442: 0x97EE,
3891     0x9443: 0x4EFB,
3892     0x9444: 0x598A,
3893     0x9445: 0x5FCD,
3894     0x9446: 0x8A8D,
3895     0x9447: 0x6FE1,
3896     0x9448: 0x79B0,
3897     0x9449: 0x7962,
3898     0x944A: 0x5BE7,
3899     0x944B: 0x8471,
3900     0x944C: 0x732B,
3901     0x944D: 0x71B1,
3902     0x944E: 0x5E74,
3903     0x944F: 0x5FF5,
3904     0x9450: 0x637B,
3905     0x9451: 0x649A,
3906     0x9452: 0x71C3,
3907     0x9453: 0x7C98,
3908     0x9454: 0x4E43,
3909     0x9455: 0x5EFC,
3910     0x9456: 0x4E4B,
3911     0x9457: 0x57DC,
3912     0x9458: 0x56A2,
3913     0x9459: 0x60A9,
3914     0x945A: 0x6FC3,
3915     0x945B: 0x7D0D,
3916     0x945C: 0x80FD,
3917     0x945D: 0x8133,
3918     0x945E: 0x81BF,
3919     0x945F: 0x8FB2,
3920     0x9460: 0x8997,
3921     0x9461: 0x86A4,
3922     0x9462: 0x5DF4,
3923     0x9463: 0x628A,
3924     0x9464: 0x64AD,
3925     0x9465: 0x8987,
3926     0x9466: 0x6777,
3927     0x9467: 0x6CE2,
3928     0x9468: 0x6D3E,
3929     0x9469: 0x7436,
3930     0x946A: 0x7834,
3931     0x946B: 0x5A46,
3932     0x946C: 0x7F75,
3933     0x946D: 0x82AD,
3934     0x946E: 0x99AC,
3935     0x946F: 0x4FF3,
3936     0x9470: 0x5EC3,
3937     0x9471: 0x62DD,
3938     0x9472: 0x6392,
3939     0x9473: 0x6557,
3940     0x9474: 0x676F,
3941     0x9475: 0x76C3,
3942     0x9476: 0x724C,
3943     0x9477: 0x80CC,
3944     0x9478: 0x80BA,
3945     0x9479: 0x8F29,
3946     0x947A: 0x914D,
3947     0x947B: 0x500D,
3948     0x947C: 0x57F9,
3949     0x947D: 0x5A92,
3950     0x947E: 0x6885,
3951     0x9480: 0x6973,
3952     0x9481: 0x7164,
3953     0x9482: 0x72FD,
3954     0x9483: 0x8CB7,
3955     0x9484: 0x58F2,
3956     0x9485: 0x8CE0,
3957     0x9486: 0x966A,
3958     0x9487: 0x9019,
3959     0x9488: 0x877F,
3960     0x9489: 0x79E4,
3961     0x948A: 0x77E7,
3962     0x948B: 0x8429,
3963     0x948C: 0x4F2F,
3964     0x948D: 0x5265,
3965     0x948E: 0x535A,
3966     0x948F: 0x62CD,
3967     0x9490: 0x67CF,
3968     0x9491: 0x6CCA,
3969     0x9492: 0x767D,
3970     0x9493: 0x7B94,
3971     0x9494: 0x7C95,
3972     0x9495: 0x8236,
3973     0x9496: 0x8584,
3974     0x9497: 0x8FEB,
3975     0x9498: 0x66DD,
3976     0x9499: 0x6F20,
3977     0x949A: 0x7206,
3978     0x949B: 0x7E1B,
3979     0x949C: 0x83AB,
3980     0x949D: 0x99C1,
3981     0x949E: 0x9EA6,
3982     0x949F: 0x51FD,
3983     0x94A0: 0x7BB1,
3984     0x94A1: 0x7872,
3985     0x94A2: 0x7BB8,
3986     0x94A3: 0x8087,
3987     0x94A4: 0x7B48,
3988     0x94A5: 0x6AE8,
3989     0x94A6: 0x5E61,
3990     0x94A7: 0x808C,
3991     0x94A8: 0x7551,
3992     0x94A9: 0x7560,
3993     0x94AA: 0x516B,
3994     0x94AB: 0x9262,
3995     0x94AC: 0x6E8C,
3996     0x94AD: 0x767A,
3997     0x94AE: 0x9197,
3998     0x94AF: 0x9AEA,
3999     0x94B0: 0x4F10,
4000     0x94B1: 0x7F70,
4001     0x94B2: 0x629C,
4002     0x94B3: 0x7B4F,
4003     0x94B4: 0x95A5,
4004     0x94B5: 0x9CE9,
4005     0x94B6: 0x567A,
4006     0x94B7: 0x5859,
4007     0x94B8: 0x86E4,
4008     0x94B9: 0x96BC,
4009     0x94BA: 0x4F34,
4010     0x94BB: 0x5224,
4011     0x94BC: 0x534A,
4012     0x94BD: 0x53CD,
4013     0x94BE: 0x53DB,
4014     0x94BF: 0x5E06,
4015     0x94C0: 0x642C,
4016     0x94C1: 0x6591,
4017     0x94C2: 0x677F,
4018     0x94C3: 0x6C3E,
4019     0x94C4: 0x6C4E,
4020     0x94C5: 0x7248,
4021     0x94C6: 0x72AF,
4022     0x94C7: 0x73ED,
4023     0x94C8: 0x7554,
4024     0x94C9: 0x7E41,
4025     0x94CA: 0x822C,
4026     0x94CB: 0x85E9,
4027     0x94CC: 0x8CA9,
4028     0x94CD: 0x7BC4,
4029     0x94CE: 0x91C6,
4030     0x94CF: 0x7169,
4031     0x94D0: 0x9812,
4032     0x94D1: 0x98EF,
4033     0x94D2: 0x633D,
4034     0x94D3: 0x6669,
4035     0x94D4: 0x756A,
4036     0x94D5: 0x76E4,
4037     0x94D6: 0x78D0,
4038     0x94D7: 0x8543,
4039     0x94D8: 0x86EE,
4040     0x94D9: 0x532A,
4041     0x94DA: 0x5351,
4042     0x94DB: 0x5426,
4043     0x94DC: 0x5983,
4044     0x94DD: 0x5E87,
4045     0x94DE: 0x5F7C,
4046     0x94DF: 0x60B2,
4047     0x94E0: 0x6249,
4048     0x94E1: 0x6279,
4049     0x94E2: 0x62AB,
4050     0x94E3: 0x6590,
4051     0x94E4: 0x6BD4,
4052     0x94E5: 0x6CCC,
4053     0x94E6: 0x75B2,
4054     0x94E7: 0x76AE,
4055     0x94E8: 0x7891,
4056     0x94E9: 0x79D8,
4057     0x94EA: 0x7DCB,
4058     0x94EB: 0x7F77,
4059     0x94EC: 0x80A5,
4060     0x94ED: 0x88AB,
4061     0x94EE: 0x8AB9,
4062     0x94EF: 0x8CBB,
4063     0x94F0: 0x907F,
4064     0x94F1: 0x975E,
4065     0x94F2: 0x98DB,
4066     0x94F3: 0x6A0B,
4067     0x94F4: 0x7C38,
4068     0x94F5: 0x5099,
4069     0x94F6: 0x5C3E,
4070     0x94F7: 0x5FAE,
4071     0x94F8: 0x6787,
4072     0x94F9: 0x6BD8,
4073     0x94FA: 0x7435,
4074     0x94FB: 0x7709,
4075     0x94FC: 0x7F8E,
4076     0x9540: 0x9F3B,
4077     0x9541: 0x67CA,
4078     0x9542: 0x7A17,
4079     0x9543: 0x5339,
4080     0x9544: 0x758B,
4081     0x9545: 0x9AED,
4082     0x9546: 0x5F66,
4083     0x9547: 0x819D,
4084     0x9548: 0x83F1,
4085     0x9549: 0x8098,
4086     0x954A: 0x5F3C,
4087     0x954B: 0x5FC5,
4088     0x954C: 0x7562,
4089     0x954D: 0x7B46,
4090     0x954E: 0x903C,
4091     0x954F: 0x6867,
4092     0x9550: 0x59EB,
4093     0x9551: 0x5A9B,
4094     0x9552: 0x7D10,
4095     0x9553: 0x767E,
4096     0x9554: 0x8B2C,
4097     0x9555: 0x4FF5,
4098     0x9556: 0x5F6A,
4099     0x9557: 0x6A19,
4100     0x9558: 0x6C37,
4101     0x9559: 0x6F02,
4102     0x955A: 0x74E2,
4103     0x955B: 0x7968,
4104     0x955C: 0x8868,
4105     0x955D: 0x8A55,
4106     0x955E: 0x8C79,
4107     0x955F: 0x5EDF,
4108     0x9560: 0x63CF,
4109     0x9561: 0x75C5,
4110     0x9562: 0x79D2,
4111     0x9563: 0x82D7,
4112     0x9564: 0x9328,
4113     0x9565: 0x92F2,
4114     0x9566: 0x849C,
4115     0x9567: 0x86ED,
4116     0x9568: 0x9C2D,
4117     0x9569: 0x54C1,
4118     0x956A: 0x5F6C,
4119     0x956B: 0x658C,
4120     0x956C: 0x6D5C,
4121     0x956D: 0x7015,
4122     0x956E: 0x8CA7,
4123     0x956F: 0x8CD3,
4124     0x9570: 0x983B,
4125     0x9571: 0x654F,
4126     0x9572: 0x74F6,
4127     0x9573: 0x4E0D,
4128     0x9574: 0x4ED8,
4129     0x9575: 0x57E0,
4130     0x9576: 0x592B,
4131     0x9577: 0x5A66,
4132     0x9578: 0x5BCC,
4133     0x9579: 0x51A8,
4134     0x957A: 0x5E03,
4135     0x957B: 0x5E9C,
4136     0x957C: 0x6016,
4137     0x957D: 0x6276,
4138     0x957E: 0x6577,
4139     0x9580: 0x65A7,
4140     0x9581: 0x666E,
4141     0x9582: 0x6D6E,
4142     0x9583: 0x7236,
4143     0x9584: 0x7B26,
4144     0x9585: 0x8150,
4145     0x9586: 0x819A,
4146     0x9587: 0x8299,
4147     0x9588: 0x8B5C,
4148     0x9589: 0x8CA0,
4149     0x958A: 0x8CE6,
4150     0x958B: 0x8D74,
4151     0x958C: 0x961C,
4152     0x958D: 0x9644,
4153     0x958E: 0x4FAE,
4154     0x958F: 0x64AB,
4155     0x9590: 0x6B66,
4156     0x9591: 0x821E,
4157     0x9592: 0x8461,
4158     0x9593: 0x856A,
4159     0x9594: 0x90E8,
4160     0x9595: 0x5C01,
4161     0x9596: 0x6953,
4162     0x9597: 0x98A8,
4163     0x9598: 0x847A,
4164     0x9599: 0x8557,
4165     0x959A: 0x4F0F,
4166     0x959B: 0x526F,
4167     0x959C: 0x5FA9,
4168     0x959D: 0x5E45,
4169     0x959E: 0x670D,
4170     0x959F: 0x798F,
4171     0x95A0: 0x8179,
4172     0x95A1: 0x8907,
4173     0x95A2: 0x8986,
4174     0x95A3: 0x6DF5,
4175     0x95A4: 0x5F17,
4176     0x95A5: 0x6255,
4177     0x95A6: 0x6CB8,
4178     0x95A7: 0x4ECF,
4179     0x95A8: 0x7269,
4180     0x95A9: 0x9B92,
4181     0x95AA: 0x5206,
4182     0x95AB: 0x543B,
4183     0x95AC: 0x5674,
4184     0x95AD: 0x58B3,
4185     0x95AE: 0x61A4,
4186     0x95AF: 0x626E,
4187     0x95B0: 0x711A,
4188     0x95B1: 0x596E,
4189     0x95B2: 0x7C89,
4190     0x95B3: 0x7CDE,
4191     0x95B4: 0x7D1B,
4192     0x95B5: 0x96F0,
4193     0x95B6: 0x6587,
4194     0x95B7: 0x805E,
4195     0x95B8: 0x4E19,
4196     0x95B9: 0x4F75,
4197     0x95BA: 0x5175,
4198     0x95BB: 0x5840,
4199     0x95BC: 0x5E63,
4200     0x95BD: 0x5E73,
4201     0x95BE: 0x5F0A,
4202     0x95BF: 0x67C4,
4203     0x95C0: 0x4E26,
4204     0x95C1: 0x853D,
4205     0x95C2: 0x9589,
4206     0x95C3: 0x965B,
4207     0x95C4: 0x7C73,
4208     0x95C5: 0x9801,
4209     0x95C6: 0x50FB,
4210     0x95C7: 0x58C1,
4211     0x95C8: 0x7656,
4212     0x95C9: 0x78A7,
4213     0x95CA: 0x5225,
4214     0x95CB: 0x77A5,
4215     0x95CC: 0x8511,
4216     0x95CD: 0x7B86,
4217     0x95CE: 0x504F,
4218     0x95CF: 0x5909,
4219     0x95D0: 0x7247,
4220     0x95D1: 0x7BC7,
4221     0x95D2: 0x7DE8,
4222     0x95D3: 0x8FBA,
4223     0x95D4: 0x8FD4,
4224     0x95D5: 0x904D,
4225     0x95D6: 0x4FBF,
4226     0x95D7: 0x52C9,
4227     0x95D8: 0x5A29,
4228     0x95D9: 0x5F01,
4229     0x95DA: 0x97AD,
4230     0x95DB: 0x4FDD,
4231     0x95DC: 0x8217,
4232     0x95DD: 0x92EA,
4233     0x95DE: 0x5703,
4234     0x95DF: 0x6355,
4235     0x95E0: 0x6B69,
4236     0x95E1: 0x752B,
4237     0x95E2: 0x88DC,
4238     0x95E3: 0x8F14,
4239     0x95E4: 0x7A42,
4240     0x95E5: 0x52DF,
4241     0x95E6: 0x5893,
4242     0x95E7: 0x6155,
4243     0x95E8: 0x620A,
4244     0x95E9: 0x66AE,
4245     0x95EA: 0x6BCD,
4246     0x95EB: 0x7C3F,
4247     0x95EC: 0x83E9,
4248     0x95ED: 0x5023,
4249     0x95EE: 0x4FF8,
4250     0x95EF: 0x5305,
4251     0x95F0: 0x5446,
4252     0x95F1: 0x5831,
4253     0x95F2: 0x5949,
4254     0x95F3: 0x5B9D,
4255     0x95F4: 0x5CF0,
4256     0x95F5: 0x5CEF,
4257     0x95F6: 0x5D29,
4258     0x95F7: 0x5E96,
4259     0x95F8: 0x62B1,
4260     0x95F9: 0x6367,
4261     0x95FA: 0x653E,
4262     0x95FB: 0x65B9,
4263     0x95FC: 0x670B,
4264     0x9640: 0x6CD5,
4265     0x9641: 0x6CE1,
4266     0x9642: 0x70F9,
4267     0x9643: 0x7832,
4268     0x9644: 0x7E2B,
4269     0x9645: 0x80DE,
4270     0x9646: 0x82B3,
4271     0x9647: 0x840C,
4272     0x9648: 0x84EC,
4273     0x9649: 0x8702,
4274     0x964A: 0x8912,
4275     0x964B: 0x8A2A,
4276     0x964C: 0x8C4A,
4277     0x964D: 0x90A6,
4278     0x964E: 0x92D2,
4279     0x964F: 0x98FD,
4280     0x9650: 0x9CF3,
4281     0x9651: 0x9D6C,
4282     0x9652: 0x4E4F,
4283     0x9653: 0x4EA1,
4284     0x9654: 0x508D,
4285     0x9655: 0x5256,
4286     0x9656: 0x574A,
4287     0x9657: 0x59A8,
4288     0x9658: 0x5E3D,
4289     0x9659: 0x5FD8,
4290     0x965A: 0x5FD9,
4291     0x965B: 0x623F,
4292     0x965C: 0x66B4,
4293     0x965D: 0x671B,
4294     0x965E: 0x67D0,
4295     0x965F: 0x68D2,
4296     0x9660: 0x5192,
4297     0x9661: 0x7D21,
4298     0x9662: 0x80AA,
4299     0x9663: 0x81A8,
4300     0x9664: 0x8B00,
4301     0x9665: 0x8C8C,
4302     0x9666: 0x8CBF,
4303     0x9667: 0x927E,
4304     0x9668: 0x9632,
4305     0x9669: 0x5420,
4306     0x966A: 0x982C,
4307     0x966B: 0x5317,
4308     0x966C: 0x50D5,
4309     0x966D: 0x535C,
4310     0x966E: 0x58A8,
4311     0x966F: 0x64B2,
4312     0x9670: 0x6734,
4313     0x9671: 0x7267,
4314     0x9672: 0x7766,
4315     0x9673: 0x7A46,
4316     0x9674: 0x91E6,
4317     0x9675: 0x52C3,
4318     0x9676: 0x6CA1,
4319     0x9677: 0x6B86,
4320     0x9678: 0x5800,
4321     0x9679: 0x5E4C,
4322     0x967A: 0x5954,
4323     0x967B: 0x672C,
4324     0x967C: 0x7FFB,
4325     0x967D: 0x51E1,
4326     0x967E: 0x76C6,
4327     0x9680: 0x6469,
4328     0x9681: 0x78E8,
4329     0x9682: 0x9B54,
4330     0x9683: 0x9EBB,
4331     0x9684: 0x57CB,
4332     0x9685: 0x59B9,
4333     0x9686: 0x6627,
4334     0x9687: 0x679A,
4335     0x9688: 0x6BCE,
4336     0x9689: 0x54E9,
4337     0x968A: 0x69D9,
4338     0x968B: 0x5E55,
4339     0x968C: 0x819C,
4340     0x968D: 0x6795,
4341     0x968E: 0x9BAA,
4342     0x968F: 0x67FE,
4343     0x9690: 0x9C52,
4344     0x9691: 0x685D,
4345     0x9692: 0x4EA6,
4346     0x9693: 0x4FE3,
4347     0x9694: 0x53C8,
4348     0x9695: 0x62B9,
4349     0x9696: 0x672B,
4350     0x9697: 0x6CAB,
4351     0x9698: 0x8FC4,
4352     0x9699: 0x4FAD,
4353     0x969A: 0x7E6D,
4354     0x969B: 0x9EBF,
4355     0x969C: 0x4E07,
4356     0x969D: 0x6162,
4357     0x969E: 0x6E80,
4358     0x969F: 0x6F2B,
4359     0x96A0: 0x8513,
4360     0x96A1: 0x5473,
4361     0x96A2: 0x672A,
4362     0x96A3: 0x9B45,
4363     0x96A4: 0x5DF3,
4364     0x96A5: 0x7B95,
4365     0x96A6: 0x5CAC,
4366     0x96A7: 0x5BC6,
4367     0x96A8: 0x871C,
4368     0x96A9: 0x6E4A,
4369     0x96AA: 0x84D1,
4370     0x96AB: 0x7A14,
4371     0x96AC: 0x8108,
4372     0x96AD: 0x5999,
4373     0x96AE: 0x7C8D,
4374     0x96AF: 0x6C11,
4375     0x96B0: 0x7720,
4376     0x96B1: 0x52D9,
4377     0x96B2: 0x5922,
4378     0x96B3: 0x7121,
4379     0x96B4: 0x725F,
4380     0x96B5: 0x77DB,
4381     0x96B6: 0x9727,
4382     0x96B7: 0x9D61,
4383     0x96B8: 0x690B,
4384     0x96B9: 0x5A7F,
4385     0x96BA: 0x5A18,
4386     0x96BB: 0x51A5,
4387     0x96BC: 0x540D,
4388     0x96BD: 0x547D,
4389     0x96BE: 0x660E,
4390     0x96BF: 0x76DF,
4391     0x96C0: 0x8FF7,
4392     0x96C1: 0x9298,
4393     0x96C2: 0x9CF4,
4394     0x96C3: 0x59EA,
4395     0x96C4: 0x725D,
4396     0x96C5: 0x6EC5,
4397     0x96C6: 0x514D,
4398     0x96C7: 0x68C9,
4399     0x96C8: 0x7DBF,
4400     0x96C9: 0x7DEC,
4401     0x96CA: 0x9762,
4402     0x96CB: 0x9EBA,
4403     0x96CC: 0x6478,
4404     0x96CD: 0x6A21,
4405     0x96CE: 0x8302,
4406     0x96CF: 0x5984,
4407     0x96D0: 0x5B5F,
4408     0x96D1: 0x6BDB,
4409     0x96D2: 0x731B,
4410     0x96D3: 0x76F2,
4411     0x96D4: 0x7DB2,
4412     0x96D5: 0x8017,
4413     0x96D6: 0x8499,
4414     0x96D7: 0x5132,
4415     0x96D8: 0x6728,
4416     0x96D9: 0x9ED9,
4417     0x96DA: 0x76EE,
4418     0x96DB: 0x6762,
4419     0x96DC: 0x52FF,
4420     0x96DD: 0x9905,
4421     0x96DE: 0x5C24,
4422     0x96DF: 0x623B,
4423     0x96E0: 0x7C7E,
4424     0x96E1: 0x8CB0,
4425     0x96E2: 0x554F,
4426     0x96E3: 0x60B6,
4427     0x96E4: 0x7D0B,
4428     0x96E5: 0x9580,
4429     0x96E6: 0x5301,
4430     0x96E7: 0x4E5F,
4431     0x96E8: 0x51B6,
4432     0x96E9: 0x591C,
4433     0x96EA: 0x723A,
4434     0x96EB: 0x8036,
4435     0x96EC: 0x91CE,
4436     0x96ED: 0x5F25,
4437     0x96EE: 0x77E2,
4438     0x96EF: 0x5384,
4439     0x96F0: 0x5F79,
4440     0x96F1: 0x7D04,
4441     0x96F2: 0x85AC,
4442     0x96F3: 0x8A33,
4443     0x96F4: 0x8E8D,
4444     0x96F5: 0x9756,
4445     0x96F6: 0x67F3,
4446     0x96F7: 0x85AE,
4447     0x96F8: 0x9453,
4448     0x96F9: 0x6109,
4449     0x96FA: 0x6108,
4450     0x96FB: 0x6CB9,
4451     0x96FC: 0x7652,
4452     0x9740: 0x8AED,
4453     0x9741: 0x8F38,
4454     0x9742: 0x552F,
4455     0x9743: 0x4F51,
4456     0x9744: 0x512A,
4457     0x9745: 0x52C7,
4458     0x9746: 0x53CB,
4459     0x9747: 0x5BA5,
4460     0x9748: 0x5E7D,
4461     0x9749: 0x60A0,
4462     0x974A: 0x6182,
4463     0x974B: 0x63D6,
4464     0x974C: 0x6709,
4465     0x974D: 0x67DA,
4466     0x974E: 0x6E67,
4467     0x974F: 0x6D8C,
4468     0x9750: 0x7336,
4469     0x9751: 0x7337,
4470     0x9752: 0x7531,
4471     0x9753: 0x7950,
4472     0x9754: 0x88D5,
4473     0x9755: 0x8A98,
4474     0x9756: 0x904A,
4475     0x9757: 0x9091,
4476     0x9758: 0x90F5,
4477     0x9759: 0x96C4,
4478     0x975A: 0x878D,
4479     0x975B: 0x5915,
4480     0x975C: 0x4E88,
4481     0x975D: 0x4F59,
4482     0x975E: 0x4E0E,
4483     0x975F: 0x8A89,
4484     0x9760: 0x8F3F,
4485     0x9761: 0x9810,
4486     0x9762: 0x50AD,
4487     0x9763: 0x5E7C,
4488     0x9764: 0x5996,
4489     0x9765: 0x5BB9,
4490     0x9766: 0x5EB8,
4491     0x9767: 0x63DA,
4492     0x9768: 0x63FA,
4493     0x9769: 0x64C1,
4494     0x976A: 0x66DC,
4495     0x976B: 0x694A,
4496     0x976C: 0x69D8,
4497     0x976D: 0x6D0B,
4498     0x976E: 0x6EB6,
4499     0x976F: 0x7194,
4500     0x9770: 0x7528,
4501     0x9771: 0x7AAF,
4502     0x9772: 0x7F8A,
4503     0x9773: 0x8000,
4504     0x9774: 0x8449,
4505     0x9775: 0x84C9,
4506     0x9776: 0x8981,
4507     0x9777: 0x8B21,
4508     0x9778: 0x8E0A,
4509     0x9779: 0x9065,
4510     0x977A: 0x967D,
4511     0x977B: 0x990A,
4512     0x977C: 0x617E,
4513     0x977D: 0x6291,
4514     0x977E: 0x6B32,
4515     0x9780: 0x6C83,
4516     0x9781: 0x6D74,
4517     0x9782: 0x7FCC,
4518     0x9783: 0x7FFC,
4519     0x9784: 0x6DC0,
4520     0x9785: 0x7F85,
4521     0x9786: 0x87BA,
4522     0x9787: 0x88F8,
4523     0x9788: 0x6765,
4524     0x9789: 0x83B1,
4525     0x978A: 0x983C,
4526     0x978B: 0x96F7,
4527     0x978C: 0x6D1B,
4528     0x978D: 0x7D61,
4529     0x978E: 0x843D,
4530     0x978F: 0x916A,
4531     0x9790: 0x4E71,
4532     0x9791: 0x5375,
4533     0x9792: 0x5D50,
4534     0x9793: 0x6B04,
4535     0x9794: 0x6FEB,
4536     0x9795: 0x85CD,
4537     0x9796: 0x862D,
4538     0x9797: 0x89A7,
4539     0x9798: 0x5229,
4540     0x9799: 0x540F,
4541     0x979A: 0x5C65,
4542     0x979B: 0x674E,
4543     0x979C: 0x68A8,
4544     0x979D: 0x7406,
4545     0x979E: 0x7483,
4546     0x979F: 0x75E2,
4547     0x97A0: 0x88CF,
4548     0x97A1: 0x88E1,
4549     0x97A2: 0x91CC,
4550     0x97A3: 0x96E2,
4551     0x97A4: 0x9678,
4552     0x97A5: 0x5F8B,
4553     0x97A6: 0x7387,
4554     0x97A7: 0x7ACB,
4555     0x97A8: 0x844E,
4556     0x97A9: 0x63A0,
4557     0x97AA: 0x7565,
4558     0x97AB: 0x5289,
4559     0x97AC: 0x6D41,
4560     0x97AD: 0x6E9C,
4561     0x97AE: 0x7409,
4562     0x97AF: 0x7559,
4563     0x97B0: 0x786B,
4564     0x97B1: 0x7C92,
4565     0x97B2: 0x9686,
4566     0x97B3: 0x7ADC,
4567     0x97B4: 0x9F8D,
4568     0x97B5: 0x4FB6,
4569     0x97B6: 0x616E,
4570     0x97B7: 0x65C5,
4571     0x97B8: 0x865C,
4572     0x97B9: 0x4E86,
4573     0x97BA: 0x4EAE,
4574     0x97BB: 0x50DA,
4575     0x97BC: 0x4E21,
4576     0x97BD: 0x51CC,
4577     0x97BE: 0x5BEE,
4578     0x97BF: 0x6599,
4579     0x97C0: 0x6881,
4580     0x97C1: 0x6DBC,
4581     0x97C2: 0x731F,
4582     0x97C3: 0x7642,
4583     0x97C4: 0x77AD,
4584     0x97C5: 0x7A1C,
4585     0x97C6: 0x7CE7,
4586     0x97C7: 0x826F,
4587     0x97C8: 0x8AD2,
4588     0x97C9: 0x907C,
4589     0x97CA: 0x91CF,
4590     0x97CB: 0x9675,
4591     0x97CC: 0x9818,
4592     0x97CD: 0x529B,
4593     0x97CE: 0x7DD1,
4594     0x97CF: 0x502B,
4595     0x97D0: 0x5398,
4596     0x97D1: 0x6797,
4597     0x97D2: 0x6DCB,
4598     0x97D3: 0x71D0,
4599     0x97D4: 0x7433,
4600     0x97D5: 0x81E8,
4601     0x97D6: 0x8F2A,
4602     0x97D7: 0x96A3,
4603     0x97D8: 0x9C57,
4604     0x97D9: 0x9E9F,
4605     0x97DA: 0x7460,
4606     0x97DB: 0x5841,
4607     0x97DC: 0x6D99,
4608     0x97DD: 0x7D2F,
4609     0x97DE: 0x985E,
4610     0x97DF: 0x4EE4,
4611     0x97E0: 0x4F36,
4612     0x97E1: 0x4F8B,
4613     0x97E2: 0x51B7,
4614     0x97E3: 0x52B1,
4615     0x97E4: 0x5DBA,
4616     0x97E5: 0x601C,
4617     0x97E6: 0x73B2,
4618     0x97E7: 0x793C,
4619     0x97E8: 0x82D3,
4620     0x97E9: 0x9234,
4621     0x97EA: 0x96B7,
4622     0x97EB: 0x96F6,
4623     0x97EC: 0x970A,
4624     0x97ED: 0x9E97,
4625     0x97EE: 0x9F62,
4626     0x97EF: 0x66A6,
4627     0x97F0: 0x6B74,
4628     0x97F1: 0x5217,
4629     0x97F2: 0x52A3,
4630     0x97F3: 0x70C8,
4631     0x97F4: 0x88C2,
4632     0x97F5: 0x5EC9,
4633     0x97F6: 0x604B,
4634     0x97F7: 0x6190,
4635     0x97F8: 0x6F23,
4636     0x97F9: 0x7149,
4637     0x97FA: 0x7C3E,
4638     0x97FB: 0x7DF4,
4639     0x97FC: 0x806F,
4640     0x9840: 0x84EE,
4641     0x9841: 0x9023,
4642     0x9842: 0x932C,
4643     0x9843: 0x5442,
4644     0x9844: 0x9B6F,
4645     0x9845: 0x6AD3,
4646     0x9846: 0x7089,
4647     0x9847: 0x8CC2,
4648     0x9848: 0x8DEF,
4649     0x9849: 0x9732,
4650     0x984A: 0x52B4,
4651     0x984B: 0x5A41,
4652     0x984C: 0x5ECA,
4653     0x984D: 0x5F04,
4654     0x984E: 0x6717,
4655     0x984F: 0x697C,
4656     0x9850: 0x6994,
4657     0x9851: 0x6D6A,
4658     0x9852: 0x6F0F,
4659     0x9853: 0x7262,
4660     0x9854: 0x72FC,
4661     0x9855: 0x7BED,
4662     0x9856: 0x8001,
4663     0x9857: 0x807E,
4664     0x9858: 0x874B,
4665     0x9859: 0x90CE,
4666     0x985A: 0x516D,
4667     0x985B: 0x9E93,
4668     0x985C: 0x7984,
4669     0x985D: 0x808B,
4670     0x985E: 0x9332,
4671     0x985F: 0x8AD6,
4672     0x9860: 0x502D,
4673     0x9861: 0x548C,
4674     0x9862: 0x8A71,
4675     0x9863: 0x6B6A,
4676     0x9864: 0x8CC4,
4677     0x9865: 0x8107,
4678     0x9866: 0x60D1,
4679     0x9867: 0x67A0,
4680     0x9868: 0x9DF2,
4681     0x9869: 0x4E99,
4682     0x986A: 0x4E98,
4683     0x986B: 0x9C10,
4684     0x986C: 0x8A6B,
4685     0x986D: 0x85C1,
4686     0x986E: 0x8568,
4687     0x986F: 0x6900,
4688     0x9870: 0x6E7E,
4689     0x9871: 0x7897,
4690     0x9872: 0x8155,
4691     0x989F: 0x5F0C,
4692     0x98A0: 0x4E10,
4693     0x98A1: 0x4E15,
4694     0x98A2: 0x4E2A,
4695     0x98A3: 0x4E31,
4696     0x98A4: 0x4E36,
4697     0x98A5: 0x4E3C,
4698     0x98A6: 0x4E3F,
4699     0x98A7: 0x4E42,
4700     0x98A8: 0x4E56,
4701     0x98A9: 0x4E58,
4702     0x98AA: 0x4E82,
4703     0x98AB: 0x4E85,
4704     0x98AC: 0x8C6B,
4705     0x98AD: 0x4E8A,
4706     0x98AE: 0x8212,
4707     0x98AF: 0x5F0D,
4708     0x98B0: 0x4E8E,
4709     0x98B1: 0x4E9E,
4710     0x98B2: 0x4E9F,
4711     0x98B3: 0x4EA0,
4712     0x98B4: 0x4EA2,
4713     0x98B5: 0x4EB0,
4714     0x98B6: 0x4EB3,
4715     0x98B7: 0x4EB6,
4716     0x98B8: 0x4ECE,
4717     0x98B9: 0x4ECD,
4718     0x98BA: 0x4EC4,
4719     0x98BB: 0x4EC6,
4720     0x98BC: 0x4EC2,
4721     0x98BD: 0x4ED7,
4722     0x98BE: 0x4EDE,
4723     0x98BF: 0x4EED,
4724     0x98C0: 0x4EDF,
4725     0x98C1: 0x4EF7,
4726     0x98C2: 0x4F09,
4727     0x98C3: 0x4F5A,
4728     0x98C4: 0x4F30,
4729     0x98C5: 0x4F5B,
4730     0x98C6: 0x4F5D,
4731     0x98C7: 0x4F57,
4732     0x98C8: 0x4F47,
4733     0x98C9: 0x4F76,
4734     0x98CA: 0x4F88,
4735     0x98CB: 0x4F8F,
4736     0x98CC: 0x4F98,
4737     0x98CD: 0x4F7B,
4738     0x98CE: 0x4F69,
4739     0x98CF: 0x4F70,
4740     0x98D0: 0x4F91,
4741     0x98D1: 0x4F6F,
4742     0x98D2: 0x4F86,
4743     0x98D3: 0x4F96,
4744     0x98D4: 0x5118,
4745     0x98D5: 0x4FD4,
4746     0x98D6: 0x4FDF,
4747     0x98D7: 0x4FCE,
4748     0x98D8: 0x4FD8,
4749     0x98D9: 0x4FDB,
4750     0x98DA: 0x4FD1,
4751     0x98DB: 0x4FDA,
4752     0x98DC: 0x4FD0,
4753     0x98DD: 0x4FE4,
4754     0x98DE: 0x4FE5,
4755     0x98DF: 0x501A,
4756     0x98E0: 0x5028,
4757     0x98E1: 0x5014,
4758     0x98E2: 0x502A,
4759     0x98E3: 0x5025,
4760     0x98E4: 0x5005,
4761     0x98E5: 0x4F1C,
4762     0x98E6: 0x4FF6,
4763     0x98E7: 0x5021,
4764     0x98E8: 0x5029,
4765     0x98E9: 0x502C,
4766     0x98EA: 0x4FFE,
4767     0x98EB: 0x4FEF,
4768     0x98EC: 0x5011,
4769     0x98ED: 0x5006,
4770     0x98EE: 0x5043,
4771     0x98EF: 0x5047,
4772     0x98F0: 0x6703,
4773     0x98F1: 0x5055,
4774     0x98F2: 0x5050,
4775     0x98F3: 0x5048,
4776     0x98F4: 0x505A,
4777     0x98F5: 0x5056,
4778     0x98F6: 0x506C,
4779     0x98F7: 0x5078,
4780     0x98F8: 0x5080,
4781     0x98F9: 0x509A,
4782     0x98FA: 0x5085,
4783     0x98FB: 0x50B4,
4784     0x98FC: 0x50B2,
4785     0x9940: 0x50C9,
4786     0x9941: 0x50CA,
4787     0x9942: 0x50B3,
4788     0x9943: 0x50C2,
4789     0x9944: 0x50D6,
4790     0x9945: 0x50DE,
4791     0x9946: 0x50E5,
4792     0x9947: 0x50ED,
4793     0x9948: 0x50E3,
4794     0x9949: 0x50EE,
4795     0x994A: 0x50F9,
4796     0x994B: 0x50F5,
4797     0x994C: 0x5109,
4798     0x994D: 0x5101,
4799     0x994E: 0x5102,
4800     0x994F: 0x5116,
4801     0x9950: 0x5115,
4802     0x9951: 0x5114,
4803     0x9952: 0x511A,
4804     0x9953: 0x5121,
4805     0x9954: 0x513A,
4806     0x9955: 0x5137,
4807     0x9956: 0x513C,
4808     0x9957: 0x513B,
4809     0x9958: 0x513F,
4810     0x9959: 0x5140,
4811     0x995A: 0x5152,
4812     0x995B: 0x514C,
4813     0x995C: 0x5154,
4814     0x995D: 0x5162,
4815     0x995E: 0x7AF8,
4816     0x995F: 0x5169,
4817     0x9960: 0x516A,
4818     0x9961: 0x516E,
4819     0x9962: 0x5180,
4820     0x9963: 0x5182,
4821     0x9964: 0x56D8,
4822     0x9965: 0x518C,
4823     0x9966: 0x5189,
4824     0x9967: 0x518F,
4825     0x9968: 0x5191,
4826     0x9969: 0x5193,
4827     0x996A: 0x5195,
4828     0x996B: 0x5196,
4829     0x996C: 0x51A4,
4830     0x996D: 0x51A6,
4831     0x996E: 0x51A2,
4832     0x996F: 0x51A9,
4833     0x9970: 0x51AA,
4834     0x9971: 0x51AB,
4835     0x9972: 0x51B3,
4836     0x9973: 0x51B1,
4837     0x9974: 0x51B2,
4838     0x9975: 0x51B0,
4839     0x9976: 0x51B5,
4840     0x9977: 0x51BD,
4841     0x9978: 0x51C5,
4842     0x9979: 0x51C9,
4843     0x997A: 0x51DB,
4844     0x997B: 0x51E0,
4845     0x997C: 0x8655,
4846     0x997D: 0x51E9,
4847     0x997E: 0x51ED,
4848     0x9980: 0x51F0,
4849     0x9981: 0x51F5,
4850     0x9982: 0x51FE,
4851     0x9983: 0x5204,
4852     0x9984: 0x520B,
4853     0x9985: 0x5214,
4854     0x9986: 0x520E,
4855     0x9987: 0x5227,
4856     0x9988: 0x522A,
4857     0x9989: 0x522E,
4858     0x998A: 0x5233,
4859     0x998B: 0x5239,
4860     0x998C: 0x524F,
4861     0x998D: 0x5244,
4862     0x998E: 0x524B,
4863     0x998F: 0x524C,
4864     0x9990: 0x525E,
4865     0x9991: 0x5254,
4866     0x9992: 0x526A,
4867     0x9993: 0x5274,
4868     0x9994: 0x5269,
4869     0x9995: 0x5273,
4870     0x9996: 0x527F,
4871     0x9997: 0x527D,
4872     0x9998: 0x528D,
4873     0x9999: 0x5294,
4874     0x999A: 0x5292,
4875     0x999B: 0x5271,
4876     0x999C: 0x5288,
4877     0x999D: 0x5291,
4878     0x999E: 0x8FA8,
4879     0x999F: 0x8FA7,
4880     0x99A0: 0x52AC,
4881     0x99A1: 0x52AD,
4882     0x99A2: 0x52BC,
4883     0x99A3: 0x52B5,
4884     0x99A4: 0x52C1,
4885     0x99A5: 0x52CD,
4886     0x99A6: 0x52D7,
4887     0x99A7: 0x52DE,
4888     0x99A8: 0x52E3,
4889     0x99A9: 0x52E6,
4890     0x99AA: 0x98ED,
4891     0x99AB: 0x52E0,
4892     0x99AC: 0x52F3,
4893     0x99AD: 0x52F5,
4894     0x99AE: 0x52F8,
4895     0x99AF: 0x52F9,
4896     0x99B0: 0x5306,
4897     0x99B1: 0x5308,
4898     0x99B2: 0x7538,
4899     0x99B3: 0x530D,
4900     0x99B4: 0x5310,
4901     0x99B5: 0x530F,
4902     0x99B6: 0x5315,
4903     0x99B7: 0x531A,
4904     0x99B8: 0x5323,
4905     0x99B9: 0x532F,
4906     0x99BA: 0x5331,
4907     0x99BB: 0x5333,
4908     0x99BC: 0x5338,
4909     0x99BD: 0x5340,
4910     0x99BE: 0x5346,
4911     0x99BF: 0x5345,
4912     0x99C0: 0x4E17,
4913     0x99C1: 0x5349,
4914     0x99C2: 0x534D,
4915     0x99C3: 0x51D6,
4916     0x99C4: 0x535E,
4917     0x99C5: 0x5369,
4918     0x99C6: 0x536E,
4919     0x99C7: 0x5918,
4920     0x99C8: 0x537B,
4921     0x99C9: 0x5377,
4922     0x99CA: 0x5382,
4923     0x99CB: 0x5396,
4924     0x99CC: 0x53A0,
4925     0x99CD: 0x53A6,
4926     0x99CE: 0x53A5,
4927     0x99CF: 0x53AE,
4928     0x99D0: 0x53B0,
4929     0x99D1: 0x53B6,
4930     0x99D2: 0x53C3,
4931     0x99D3: 0x7C12,
4932     0x99D4: 0x96D9,
4933     0x99D5: 0x53DF,
4934     0x99D6: 0x66FC,
4935     0x99D7: 0x71EE,
4936     0x99D8: 0x53EE,
4937     0x99D9: 0x53E8,
4938     0x99DA: 0x53ED,
4939     0x99DB: 0x53FA,
4940     0x99DC: 0x5401,
4941     0x99DD: 0x543D,
4942     0x99DE: 0x5440,
4943     0x99DF: 0x542C,
4944     0x99E0: 0x542D,
4945     0x99E1: 0x543C,
4946     0x99E2: 0x542E,
4947     0x99E3: 0x5436,
4948     0x99E4: 0x5429,
4949     0x99E5: 0x541D,
4950     0x99E6: 0x544E,
4951     0x99E7: 0x548F,
4952     0x99E8: 0x5475,
4953     0x99E9: 0x548E,
4954     0x99EA: 0x545F,
4955     0x99EB: 0x5471,
4956     0x99EC: 0x5477,
4957     0x99ED: 0x5470,
4958     0x99EE: 0x5492,
4959     0x99EF: 0x547B,
4960     0x99F0: 0x5480,
4961     0x99F1: 0x5476,
4962     0x99F2: 0x5484,
4963     0x99F3: 0x5490,
4964     0x99F4: 0x5486,
4965     0x99F5: 0x54C7,
4966     0x99F6: 0x54A2,
4967     0x99F7: 0x54B8,
4968     0x99F8: 0x54A5,
4969     0x99F9: 0x54AC,
4970     0x99FA: 0x54C4,
4971     0x99FB: 0x54C8,
4972     0x99FC: 0x54A8,
4973     0x9A40: 0x54AB,
4974     0x9A41: 0x54C2,
4975     0x9A42: 0x54A4,
4976     0x9A43: 0x54BE,
4977     0x9A44: 0x54BC,
4978     0x9A45: 0x54D8,
4979     0x9A46: 0x54E5,
4980     0x9A47: 0x54E6,
4981     0x9A48: 0x550F,
4982     0x9A49: 0x5514,
4983     0x9A4A: 0x54FD,
4984     0x9A4B: 0x54EE,
4985     0x9A4C: 0x54ED,
4986     0x9A4D: 0x54FA,
4987     0x9A4E: 0x54E2,
4988     0x9A4F: 0x5539,
4989     0x9A50: 0x5540,
4990     0x9A51: 0x5563,
4991     0x9A52: 0x554C,
4992     0x9A53: 0x552E,
4993     0x9A54: 0x555C,
4994     0x9A55: 0x5545,
4995     0x9A56: 0x5556,
4996     0x9A57: 0x5557,
4997     0x9A58: 0x5538,
4998     0x9A59: 0x5533,
4999     0x9A5A: 0x555D,
5000     0x9A5B: 0x5599,
5001     0x9A5C: 0x5580,
5002     0x9A5D: 0x54AF,
5003     0x9A5E: 0x558A,
5004     0x9A5F: 0x559F,
5005     0x9A60: 0x557B,
5006     0x9A61: 0x557E,
5007     0x9A62: 0x5598,
5008     0x9A63: 0x559E,
5009     0x9A64: 0x55AE,
5010     0x9A65: 0x557C,
5011     0x9A66: 0x5583,
5012     0x9A67: 0x55A9,
5013     0x9A68: 0x5587,
5014     0x9A69: 0x55A8,
5015     0x9A6A: 0x55DA,
5016     0x9A6B: 0x55C5,
5017     0x9A6C: 0x55DF,
5018     0x9A6D: 0x55C4,
5019     0x9A6E: 0x55DC,
5020     0x9A6F: 0x55E4,
5021     0x9A70: 0x55D4,
5022     0x9A71: 0x5614,
5023     0x9A72: 0x55F7,
5024     0x9A73: 0x5616,
5025     0x9A74: 0x55FE,
5026     0x9A75: 0x55FD,
5027     0x9A76: 0x561B,
5028     0x9A77: 0x55F9,
5029     0x9A78: 0x564E,
5030     0x9A79: 0x5650,
5031     0x9A7A: 0x71DF,
5032     0x9A7B: 0x5634,
5033     0x9A7C: 0x5636,
5034     0x9A7D: 0x5632,
5035     0x9A7E: 0x5638,
5036     0x9A80: 0x566B,
5037     0x9A81: 0x5664,
5038     0x9A82: 0x562F,
5039     0x9A83: 0x566C,
5040     0x9A84: 0x566A,
5041     0x9A85: 0x5686,
5042     0x9A86: 0x5680,
5043     0x9A87: 0x568A,
5044     0x9A88: 0x56A0,
5045     0x9A89: 0x5694,
5046     0x9A8A: 0x568F,
5047     0x9A8B: 0x56A5,
5048     0x9A8C: 0x56AE,
5049     0x9A8D: 0x56B6,
5050     0x9A8E: 0x56B4,
5051     0x9A8F: 0x56C2,
5052     0x9A90: 0x56BC,
5053     0x9A91: 0x56C1,
5054     0x9A92: 0x56C3,
5055     0x9A93: 0x56C0,
5056     0x9A94: 0x56C8,
5057     0x9A95: 0x56CE,
5058     0x9A96: 0x56D1,
5059     0x9A97: 0x56D3,
5060     0x9A98: 0x56D7,
5061     0x9A99: 0x56EE,
5062     0x9A9A: 0x56F9,
5063     0x9A9B: 0x5700,
5064     0x9A9C: 0x56FF,
5065     0x9A9D: 0x5704,
5066     0x9A9E: 0x5709,
5067     0x9A9F: 0x5708,
5068     0x9AA0: 0x570B,
5069     0x9AA1: 0x570D,
5070     0x9AA2: 0x5713,
5071     0x9AA3: 0x5718,
5072     0x9AA4: 0x5716,
5073     0x9AA5: 0x55C7,
5074     0x9AA6: 0x571C,
5075     0x9AA7: 0x5726,
5076     0x9AA8: 0x5737,
5077     0x9AA9: 0x5738,
5078     0x9AAA: 0x574E,
5079     0x9AAB: 0x573B,
5080     0x9AAC: 0x5740,
5081     0x9AAD: 0x574F,
5082     0x9AAE: 0x5769,
5083     0x9AAF: 0x57C0,
5084     0x9AB0: 0x5788,
5085     0x9AB1: 0x5761,
5086     0x9AB2: 0x577F,
5087     0x9AB3: 0x5789,
5088     0x9AB4: 0x5793,
5089     0x9AB5: 0x57A0,
5090     0x9AB6: 0x57B3,
5091     0x9AB7: 0x57A4,
5092     0x9AB8: 0x57AA,
5093     0x9AB9: 0x57B0,
5094     0x9ABA: 0x57C3,
5095     0x9ABB: 0x57C6,
5096     0x9ABC: 0x57D4,
5097     0x9ABD: 0x57D2,
5098     0x9ABE: 0x57D3,
5099     0x9ABF: 0x580A,
5100     0x9AC0: 0x57D6,
5101     0x9AC1: 0x57E3,
5102     0x9AC2: 0x580B,
5103     0x9AC3: 0x5819,
5104     0x9AC4: 0x581D,
5105     0x9AC5: 0x5872,
5106     0x9AC6: 0x5821,
5107     0x9AC7: 0x5862,
5108     0x9AC8: 0x584B,
5109     0x9AC9: 0x5870,
5110     0x9ACA: 0x6BC0,
5111     0x9ACB: 0x5852,
5112     0x9ACC: 0x583D,
5113     0x9ACD: 0x5879,
5114     0x9ACE: 0x5885,
5115     0x9ACF: 0x58B9,
5116     0x9AD0: 0x589F,
5117     0x9AD1: 0x58AB,
5118     0x9AD2: 0x58BA,
5119     0x9AD3: 0x58DE,
5120     0x9AD4: 0x58BB,
5121     0x9AD5: 0x58B8,
5122     0x9AD6: 0x58AE,
5123     0x9AD7: 0x58C5,
5124     0x9AD8: 0x58D3,
5125     0x9AD9: 0x58D1,
5126     0x9ADA: 0x58D7,
5127     0x9ADB: 0x58D9,
5128     0x9ADC: 0x58D8,
5129     0x9ADD: 0x58E5,
5130     0x9ADE: 0x58DC,
5131     0x9ADF: 0x58E4,
5132     0x9AE0: 0x58DF,
5133     0x9AE1: 0x58EF,
5134     0x9AE2: 0x58FA,
5135     0x9AE3: 0x58F9,
5136     0x9AE4: 0x58FB,
5137     0x9AE5: 0x58FC,
5138     0x9AE6: 0x58FD,
5139     0x9AE7: 0x5902,
5140     0x9AE8: 0x590A,
5141     0x9AE9: 0x5910,
5142     0x9AEA: 0x591B,
5143     0x9AEB: 0x68A6,
5144     0x9AEC: 0x5925,
5145     0x9AED: 0x592C,
5146     0x9AEE: 0x592D,
5147     0x9AEF: 0x5932,
5148     0x9AF0: 0x5938,
5149     0x9AF1: 0x593E,
5150     0x9AF2: 0x7AD2,
5151     0x9AF3: 0x5955,
5152     0x9AF4: 0x5950,
5153     0x9AF5: 0x594E,
5154     0x9AF6: 0x595A,
5155     0x9AF7: 0x5958,
5156     0x9AF8: 0x5962,
5157     0x9AF9: 0x5960,
5158     0x9AFA: 0x5967,
5159     0x9AFB: 0x596C,
5160     0x9AFC: 0x5969,
5161     0x9B40: 0x5978,
5162     0x9B41: 0x5981,
5163     0x9B42: 0x599D,
5164     0x9B43: 0x4F5E,
5165     0x9B44: 0x4FAB,
5166     0x9B45: 0x59A3,
5167     0x9B46: 0x59B2,
5168     0x9B47: 0x59C6,
5169     0x9B48: 0x59E8,
5170     0x9B49: 0x59DC,
5171     0x9B4A: 0x598D,
5172     0x9B4B: 0x59D9,
5173     0x9B4C: 0x59DA,
5174     0x9B4D: 0x5A25,
5175     0x9B4E: 0x5A1F,
5176     0x9B4F: 0x5A11,
5177     0x9B50: 0x5A1C,
5178     0x9B51: 0x5A09,
5179     0x9B52: 0x5A1A,
5180     0x9B53: 0x5A40,
5181     0x9B54: 0x5A6C,
5182     0x9B55: 0x5A49,
5183     0x9B56: 0x5A35,
5184     0x9B57: 0x5A36,
5185     0x9B58: 0x5A62,
5186     0x9B59: 0x5A6A,
5187     0x9B5A: 0x5A9A,
5188     0x9B5B: 0x5ABC,
5189     0x9B5C: 0x5ABE,
5190     0x9B5D: 0x5ACB,
5191     0x9B5E: 0x5AC2,
5192     0x9B5F: 0x5ABD,
5193     0x9B60: 0x5AE3,
5194     0x9B61: 0x5AD7,
5195     0x9B62: 0x5AE6,
5196     0x9B63: 0x5AE9,
5197     0x9B64: 0x5AD6,
5198     0x9B65: 0x5AFA,
5199     0x9B66: 0x5AFB,
5200     0x9B67: 0x5B0C,
5201     0x9B68: 0x5B0B,
5202     0x9B69: 0x5B16,
5203     0x9B6A: 0x5B32,
5204     0x9B6B: 0x5AD0,
5205     0x9B6C: 0x5B2A,
5206     0x9B6D: 0x5B36,
5207     0x9B6E: 0x5B3E,
5208     0x9B6F: 0x5B43,
5209     0x9B70: 0x5B45,
5210     0x9B71: 0x5B40,
5211     0x9B72: 0x5B51,
5212     0x9B73: 0x5B55,
5213     0x9B74: 0x5B5A,
5214     0x9B75: 0x5B5B,
5215     0x9B76: 0x5B65,
5216     0x9B77: 0x5B69,
5217     0x9B78: 0x5B70,
5218     0x9B79: 0x5B73,
5219     0x9B7A: 0x5B75,
5220     0x9B7B: 0x5B78,
5221     0x9B7C: 0x6588,
5222     0x9B7D: 0x5B7A,
5223     0x9B7E: 0x5B80,
5224     0x9B80: 0x5B83,
5225     0x9B81: 0x5BA6,
5226     0x9B82: 0x5BB8,
5227     0x9B83: 0x5BC3,
5228     0x9B84: 0x5BC7,
5229     0x9B85: 0x5BC9,
5230     0x9B86: 0x5BD4,
5231     0x9B87: 0x5BD0,
5232     0x9B88: 0x5BE4,
5233     0x9B89: 0x5BE6,
5234     0x9B8A: 0x5BE2,
5235     0x9B8B: 0x5BDE,
5236     0x9B8C: 0x5BE5,
5237     0x9B8D: 0x5BEB,
5238     0x9B8E: 0x5BF0,
5239     0x9B8F: 0x5BF6,
5240     0x9B90: 0x5BF3,
5241     0x9B91: 0x5C05,
5242     0x9B92: 0x5C07,
5243     0x9B93: 0x5C08,
5244     0x9B94: 0x5C0D,
5245     0x9B95: 0x5C13,
5246     0x9B96: 0x5C20,
5247     0x9B97: 0x5C22,
5248     0x9B98: 0x5C28,
5249     0x9B99: 0x5C38,
5250     0x9B9A: 0x5C39,
5251     0x9B9B: 0x5C41,
5252     0x9B9C: 0x5C46,
5253     0x9B9D: 0x5C4E,
5254     0x9B9E: 0x5C53,
5255     0x9B9F: 0x5C50,
5256     0x9BA0: 0x5C4F,
5257     0x9BA1: 0x5B71,
5258     0x9BA2: 0x5C6C,
5259     0x9BA3: 0x5C6E,
5260     0x9BA4: 0x4E62,
5261     0x9BA5: 0x5C76,
5262     0x9BA6: 0x5C79,
5263     0x9BA7: 0x5C8C,
5264     0x9BA8: 0x5C91,
5265     0x9BA9: 0x5C94,
5266     0x9BAA: 0x599B,
5267     0x9BAB: 0x5CAB,
5268     0x9BAC: 0x5CBB,
5269     0x9BAD: 0x5CB6,
5270     0x9BAE: 0x5CBC,
5271     0x9BAF: 0x5CB7,
5272     0x9BB0: 0x5CC5,
5273     0x9BB1: 0x5CBE,
5274     0x9BB2: 0x5CC7,
5275     0x9BB3: 0x5CD9,
5276     0x9BB4: 0x5CE9,
5277     0x9BB5: 0x5CFD,
5278     0x9BB6: 0x5CFA,
5279     0x9BB7: 0x5CED,
5280     0x9BB8: 0x5D8C,
5281     0x9BB9: 0x5CEA,
5282     0x9BBA: 0x5D0B,
5283     0x9BBB: 0x5D15,
5284     0x9BBC: 0x5D17,
5285     0x9BBD: 0x5D5C,
5286     0x9BBE: 0x5D1F,
5287     0x9BBF: 0x5D1B,
5288     0x9BC0: 0x5D11,
5289     0x9BC1: 0x5D14,
5290     0x9BC2: 0x5D22,
5291     0x9BC3: 0x5D1A,
5292     0x9BC4: 0x5D19,
5293     0x9BC5: 0x5D18,
5294     0x9BC6: 0x5D4C,
5295     0x9BC7: 0x5D52,
5296     0x9BC8: 0x5D4E,
5297     0x9BC9: 0x5D4B,
5298     0x9BCA: 0x5D6C,
5299     0x9BCB: 0x5D73,
5300     0x9BCC: 0x5D76,
5301     0x9BCD: 0x5D87,
5302     0x9BCE: 0x5D84,
5303     0x9BCF: 0x5D82,
5304     0x9BD0: 0x5DA2,
5305     0x9BD1: 0x5D9D,
5306     0x9BD2: 0x5DAC,
5307     0x9BD3: 0x5DAE,
5308     0x9BD4: 0x5DBD,
5309     0x9BD5: 0x5D90,
5310     0x9BD6: 0x5DB7,
5311     0x9BD7: 0x5DBC,
5312     0x9BD8: 0x5DC9,
5313     0x9BD9: 0x5DCD,
5314     0x9BDA: 0x5DD3,
5315     0x9BDB: 0x5DD2,
5316     0x9BDC: 0x5DD6,
5317     0x9BDD: 0x5DDB,
5318     0x9BDE: 0x5DEB,
5319     0x9BDF: 0x5DF2,
5320     0x9BE0: 0x5DF5,
5321     0x9BE1: 0x5E0B,
5322     0x9BE2: 0x5E1A,
5323     0x9BE3: 0x5E19,
5324     0x9BE4: 0x5E11,
5325     0x9BE5: 0x5E1B,
5326     0x9BE6: 0x5E36,
5327     0x9BE7: 0x5E37,
5328     0x9BE8: 0x5E44,
5329     0x9BE9: 0x5E43,
5330     0x9BEA: 0x5E40,
5331     0x9BEB: 0x5E4E,
5332     0x9BEC: 0x5E57,
5333     0x9BED: 0x5E54,
5334     0x9BEE: 0x5E5F,
5335     0x9BEF: 0x5E62,
5336     0x9BF0: 0x5E64,
5337     0x9BF1: 0x5E47,
5338     0x9BF2: 0x5E75,
5339     0x9BF3: 0x5E76,
5340     0x9BF4: 0x5E7A,
5341     0x9BF5: 0x9EBC,
5342     0x9BF6: 0x5E7F,
5343     0x9BF7: 0x5EA0,
5344     0x9BF8: 0x5EC1,
5345     0x9BF9: 0x5EC2,
5346     0x9BFA: 0x5EC8,
5347     0x9BFB: 0x5ED0,
5348     0x9BFC: 0x5ECF,
5349     0x9C40: 0x5ED6,
5350     0x9C41: 0x5EE3,
5351     0x9C42: 0x5EDD,
5352     0x9C43: 0x5EDA,
5353     0x9C44: 0x5EDB,
5354     0x9C45: 0x5EE2,
5355     0x9C46: 0x5EE1,
5356     0x9C47: 0x5EE8,
5357     0x9C48: 0x5EE9,
5358     0x9C49: 0x5EEC,
5359     0x9C4A: 0x5EF1,
5360     0x9C4B: 0x5EF3,
5361     0x9C4C: 0x5EF0,
5362     0x9C4D: 0x5EF4,
5363     0x9C4E: 0x5EF8,
5364     0x9C4F: 0x5EFE,
5365     0x9C50: 0x5F03,
5366     0x9C51: 0x5F09,
5367     0x9C52: 0x5F5D,
5368     0x9C53: 0x5F5C,
5369     0x9C54: 0x5F0B,
5370     0x9C55: 0x5F11,
5371     0x9C56: 0x5F16,
5372     0x9C57: 0x5F29,
5373     0x9C58: 0x5F2D,
5374     0x9C59: 0x5F38,
5375     0x9C5A: 0x5F41,
5376     0x9C5B: 0x5F48,
5377     0x9C5C: 0x5F4C,
5378     0x9C5D: 0x5F4E,
5379     0x9C5E: 0x5F2F,
5380     0x9C5F: 0x5F51,
5381     0x9C60: 0x5F56,
5382     0x9C61: 0x5F57,
5383     0x9C62: 0x5F59,
5384     0x9C63: 0x5F61,
5385     0x9C64: 0x5F6D,
5386     0x9C65: 0x5F73,
5387     0x9C66: 0x5F77,
5388     0x9C67: 0x5F83,
5389     0x9C68: 0x5F82,
5390     0x9C69: 0x5F7F,
5391     0x9C6A: 0x5F8A,
5392     0x9C6B: 0x5F88,
5393     0x9C6C: 0x5F91,
5394     0x9C6D: 0x5F87,
5395     0x9C6E: 0x5F9E,
5396     0x9C6F: 0x5F99,
5397     0x9C70: 0x5F98,
5398     0x9C71: 0x5FA0,
5399     0x9C72: 0x5FA8,
5400     0x9C73: 0x5FAD,
5401     0x9C74: 0x5FBC,
5402     0x9C75: 0x5FD6,
5403     0x9C76: 0x5FFB,
5404     0x9C77: 0x5FE4,
5405     0x9C78: 0x5FF8,
5406     0x9C79: 0x5FF1,
5407     0x9C7A: 0x5FDD,
5408     0x9C7B: 0x60B3,
5409     0x9C7C: 0x5FFF,
5410     0x9C7D: 0x6021,
5411     0x9C7E: 0x6060,
5412     0x9C80: 0x6019,
5413     0x9C81: 0x6010,
5414     0x9C82: 0x6029,
5415     0x9C83: 0x600E,
5416     0x9C84: 0x6031,
5417     0x9C85: 0x601B,
5418     0x9C86: 0x6015,
5419     0x9C87: 0x602B,
5420     0x9C88: 0x6026,
5421     0x9C89: 0x600F,
5422     0x9C8A: 0x603A,
5423     0x9C8B: 0x605A,
5424     0x9C8C: 0x6041,
5425     0x9C8D: 0x606A,
5426     0x9C8E: 0x6077,
5427     0x9C8F: 0x605F,
5428     0x9C90: 0x604A,
5429     0x9C91: 0x6046,
5430     0x9C92: 0x604D,
5431     0x9C93: 0x6063,
5432     0x9C94: 0x6043,
5433     0x9C95: 0x6064,
5434     0x9C96: 0x6042,
5435     0x9C97: 0x606C,
5436     0x9C98: 0x606B,
5437     0x9C99: 0x6059,
5438     0x9C9A: 0x6081,
5439     0x9C9B: 0x608D,
5440     0x9C9C: 0x60E7,
5441     0x9C9D: 0x6083,
5442     0x9C9E: 0x609A,
5443     0x9C9F: 0x6084,
5444     0x9CA0: 0x609B,
5445     0x9CA1: 0x6096,
5446     0x9CA2: 0x6097,
5447     0x9CA3: 0x6092,
5448     0x9CA4: 0x60A7,
5449     0x9CA5: 0x608B,
5450     0x9CA6: 0x60E1,
5451     0x9CA7: 0x60B8,
5452     0x9CA8: 0x60E0,
5453     0x9CA9: 0x60D3,
5454     0x9CAA: 0x60B4,
5455     0x9CAB: 0x5FF0,
5456     0x9CAC: 0x60BD,
5457     0x9CAD: 0x60C6,
5458     0x9CAE: 0x60B5,
5459     0x9CAF: 0x60D8,
5460     0x9CB0: 0x614D,
5461     0x9CB1: 0x6115,
5462     0x9CB2: 0x6106,
5463     0x9CB3: 0x60F6,
5464     0x9CB4: 0x60F7,
5465     0x9CB5: 0x6100,
5466     0x9CB6: 0x60F4,
5467     0x9CB7: 0x60FA,
5468     0x9CB8: 0x6103,
5469     0x9CB9: 0x6121,
5470     0x9CBA: 0x60FB,
5471     0x9CBB: 0x60F1,
5472     0x9CBC: 0x610D,
5473     0x9CBD: 0x610E,
5474     0x9CBE: 0x6147,
5475     0x9CBF: 0x613E,
5476     0x9CC0: 0x6128,
5477     0x9CC1: 0x6127,
5478     0x9CC2: 0x614A,
5479     0x9CC3: 0x613F,
5480     0x9CC4: 0x613C,
5481     0x9CC5: 0x612C,
5482     0x9CC6: 0x6134,
5483     0x9CC7: 0x613D,
5484     0x9CC8: 0x6142,
5485     0x9CC9: 0x6144,
5486     0x9CCA: 0x6173,
5487     0x9CCB: 0x6177,
5488     0x9CCC: 0x6158,
5489     0x9CCD: 0x6159,
5490     0x9CCE: 0x615A,
5491     0x9CCF: 0x616B,
5492     0x9CD0: 0x6174,
5493     0x9CD1: 0x616F,
5494     0x9CD2: 0x6165,
5495     0x9CD3: 0x6171,
5496     0x9CD4: 0x615F,
5497     0x9CD5: 0x615D,
5498     0x9CD6: 0x6153,
5499     0x9CD7: 0x6175,
5500     0x9CD8: 0x6199,
5501     0x9CD9: 0x6196,
5502     0x9CDA: 0x6187,
5503     0x9CDB: 0x61AC,
5504     0x9CDC: 0x6194,
5505     0x9CDD: 0x619A,
5506     0x9CDE: 0x618A,
5507     0x9CDF: 0x6191,
5508     0x9CE0: 0x61AB,
5509     0x9CE1: 0x61AE,
5510     0x9CE2: 0x61CC,
5511     0x9CE3: 0x61CA,
5512     0x9CE4: 0x61C9,
5513     0x9CE5: 0x61F7,
5514     0x9CE6: 0x61C8,
5515     0x9CE7: 0x61C3,
5516     0x9CE8: 0x61C6,
5517     0x9CE9: 0x61BA,
5518     0x9CEA: 0x61CB,
5519     0x9CEB: 0x7F79,
5520     0x9CEC: 0x61CD,
5521     0x9CED: 0x61E6,
5522     0x9CEE: 0x61E3,
5523     0x9CEF: 0x61F6,
5524     0x9CF0: 0x61FA,
5525     0x9CF1: 0x61F4,
5526     0x9CF2: 0x61FF,
5527     0x9CF3: 0x61FD,
5528     0x9CF4: 0x61FC,
5529     0x9CF5: 0x61FE,
5530     0x9CF6: 0x6200,
5531     0x9CF7: 0x6208,
5532     0x9CF8: 0x6209,
5533     0x9CF9: 0x620D,
5534     0x9CFA: 0x620C,
5535     0x9CFB: 0x6214,
5536     0x9CFC: 0x621B,
5537     0x9D40: 0x621E,
5538     0x9D41: 0x6221,
5539     0x9D42: 0x622A,
5540     0x9D43: 0x622E,
5541     0x9D44: 0x6230,
5542     0x9D45: 0x6232,
5543     0x9D46: 0x6233,
5544     0x9D47: 0x6241,
5545     0x9D48: 0x624E,
5546     0x9D49: 0x625E,
5547     0x9D4A: 0x6263,
5548     0x9D4B: 0x625B,
5549     0x9D4C: 0x6260,
5550     0x9D4D: 0x6268,
5551     0x9D4E: 0x627C,
5552     0x9D4F: 0x6282,
5553     0x9D50: 0x6289,
5554     0x9D51: 0x627E,
5555     0x9D52: 0x6292,
5556     0x9D53: 0x6293,
5557     0x9D54: 0x6296,
5558     0x9D55: 0x62D4,
5559     0x9D56: 0x6283,
5560     0x9D57: 0x6294,
5561     0x9D58: 0x62D7,
5562     0x9D59: 0x62D1,
5563     0x9D5A: 0x62BB,
5564     0x9D5B: 0x62CF,
5565     0x9D5C: 0x62FF,
5566     0x9D5D: 0x62C6,
5567     0x9D5E: 0x64D4,
5568     0x9D5F: 0x62C8,
5569     0x9D60: 0x62DC,
5570     0x9D61: 0x62CC,
5571     0x9D62: 0x62CA,
5572     0x9D63: 0x62C2,
5573     0x9D64: 0x62C7,
5574     0x9D65: 0x629B,
5575     0x9D66: 0x62C9,
5576     0x9D67: 0x630C,
5577     0x9D68: 0x62EE,
5578     0x9D69: 0x62F1,
5579     0x9D6A: 0x6327,
5580     0x9D6B: 0x6302,
5581     0x9D6C: 0x6308,
5582     0x9D6D: 0x62EF,
5583     0x9D6E: 0x62F5,
5584     0x9D6F: 0x6350,
5585     0x9D70: 0x633E,
5586     0x9D71: 0x634D,
5587     0x9D72: 0x641C,
5588     0x9D73: 0x634F,
5589     0x9D74: 0x6396,
5590     0x9D75: 0x638E,
5591     0x9D76: 0x6380,
5592     0x9D77: 0x63AB,
5593     0x9D78: 0x6376,
5594     0x9D79: 0x63A3,
5595     0x9D7A: 0x638F,
5596     0x9D7B: 0x6389,
5597     0x9D7C: 0x639F,
5598     0x9D7D: 0x63B5,
5599     0x9D7E: 0x636B,
5600     0x9D80: 0x6369,
5601     0x9D81: 0x63BE,
5602     0x9D82: 0x63E9,
5603     0x9D83: 0x63C0,
5604     0x9D84: 0x63C6,
5605     0x9D85: 0x63E3,
5606     0x9D86: 0x63C9,
5607     0x9D87: 0x63D2,
5608     0x9D88: 0x63F6,
5609     0x9D89: 0x63C4,
5610     0x9D8A: 0x6416,
5611     0x9D8B: 0x6434,
5612     0x9D8C: 0x6406,
5613     0x9D8D: 0x6413,
5614     0x9D8E: 0x6426,
5615     0x9D8F: 0x6436,
5616     0x9D90: 0x651D,
5617     0x9D91: 0x6417,
5618     0x9D92: 0x6428,
5619     0x9D93: 0x640F,
5620     0x9D94: 0x6467,
5621     0x9D95: 0x646F,
5622     0x9D96: 0x6476,
5623     0x9D97: 0x644E,
5624     0x9D98: 0x652A,
5625     0x9D99: 0x6495,
5626     0x9D9A: 0x6493,
5627     0x9D9B: 0x64A5,
5628     0x9D9C: 0x64A9,
5629     0x9D9D: 0x6488,
5630     0x9D9E: 0x64BC,
5631     0x9D9F: 0x64DA,
5632     0x9DA0: 0x64D2,
5633     0x9DA1: 0x64C5,
5634     0x9DA2: 0x64C7,
5635     0x9DA3: 0x64BB,
5636     0x9DA4: 0x64D8,
5637     0x9DA5: 0x64C2,
5638     0x9DA6: 0x64F1,
5639     0x9DA7: 0x64E7,
5640     0x9DA8: 0x8209,
5641     0x9DA9: 0x64E0,
5642     0x9DAA: 0x64E1,
5643     0x9DAB: 0x62AC,
5644     0x9DAC: 0x64E3,
5645     0x9DAD: 0x64EF,
5646     0x9DAE: 0x652C,
5647     0x9DAF: 0x64F6,
5648     0x9DB0: 0x64F4,
5649     0x9DB1: 0x64F2,
5650     0x9DB2: 0x64FA,
5651     0x9DB3: 0x6500,
5652     0x9DB4: 0x64FD,
5653     0x9DB5: 0x6518,
5654     0x9DB6: 0x651C,
5655     0x9DB7: 0x6505,
5656     0x9DB8: 0x6524,
5657     0x9DB9: 0x6523,
5658     0x9DBA: 0x652B,
5659     0x9DBB: 0x6534,
5660     0x9DBC: 0x6535,
5661     0x9DBD: 0x6537,
5662     0x9DBE: 0x6536,
5663     0x9DBF: 0x6538,
5664     0x9DC0: 0x754B,
5665     0x9DC1: 0x6548,
5666     0x9DC2: 0x6556,
5667     0x9DC3: 0x6555,
5668     0x9DC4: 0x654D,
5669     0x9DC5: 0x6558,
5670     0x9DC6: 0x655E,
5671     0x9DC7: 0x655D,
5672     0x9DC8: 0x6572,
5673     0x9DC9: 0x6578,
5674     0x9DCA: 0x6582,
5675     0x9DCB: 0x6583,
5676     0x9DCC: 0x8B8A,
5677     0x9DCD: 0x659B,
5678     0x9DCE: 0x659F,
5679     0x9DCF: 0x65AB,
5680     0x9DD0: 0x65B7,
5681     0x9DD1: 0x65C3,
5682     0x9DD2: 0x65C6,
5683     0x9DD3: 0x65C1,
5684     0x9DD4: 0x65C4,
5685     0x9DD5: 0x65CC,
5686     0x9DD6: 0x65D2,
5687     0x9DD7: 0x65DB,
5688     0x9DD8: 0x65D9,
5689     0x9DD9: 0x65E0,
5690     0x9DDA: 0x65E1,
5691     0x9DDB: 0x65F1,
5692     0x9DDC: 0x6772,
5693     0x9DDD: 0x660A,
5694     0x9DDE: 0x6603,
5695     0x9DDF: 0x65FB,
5696     0x9DE0: 0x6773,
5697     0x9DE1: 0x6635,
5698     0x9DE2: 0x6636,
5699     0x9DE3: 0x6634,
5700     0x9DE4: 0x661C,
5701     0x9DE5: 0x664F,
5702     0x9DE6: 0x6644,
5703     0x9DE7: 0x6649,
5704     0x9DE8: 0x6641,
5705     0x9DE9: 0x665E,
5706     0x9DEA: 0x665D,
5707     0x9DEB: 0x6664,
5708     0x9DEC: 0x6667,
5709     0x9DED: 0x6668,
5710     0x9DEE: 0x665F,
5711     0x9DEF: 0x6662,
5712     0x9DF0: 0x6670,
5713     0x9DF1: 0x6683,
5714     0x9DF2: 0x6688,
5715     0x9DF3: 0x668E,
5716     0x9DF4: 0x6689,
5717     0x9DF5: 0x6684,
5718     0x9DF6: 0x6698,
5719     0x9DF7: 0x669D,
5720     0x9DF8: 0x66C1,
5721     0x9DF9: 0x66B9,
5722     0x9DFA: 0x66C9,
5723     0x9DFB: 0x66BE,
5724     0x9DFC: 0x66BC,
5725     0x9E40: 0x66C4,
5726     0x9E41: 0x66B8,
5727     0x9E42: 0x66D6,
5728     0x9E43: 0x66DA,
5729     0x9E44: 0x66E0,
5730     0x9E45: 0x663F,
5731     0x9E46: 0x66E6,
5732     0x9E47: 0x66E9,
5733     0x9E48: 0x66F0,
5734     0x9E49: 0x66F5,
5735     0x9E4A: 0x66F7,
5736     0x9E4B: 0x670F,
5737     0x9E4C: 0x6716,
5738     0x9E4D: 0x671E,
5739     0x9E4E: 0x6726,
5740     0x9E4F: 0x6727,
5741     0x9E50: 0x9738,
5742     0x9E51: 0x672E,
5743     0x9E52: 0x673F,
5744     0x9E53: 0x6736,
5745     0x9E54: 0x6741,
5746     0x9E55: 0x6738,
5747     0x9E56: 0x6737,
5748     0x9E57: 0x6746,
5749     0x9E58: 0x675E,
5750     0x9E59: 0x6760,
5751     0x9E5A: 0x6759,
5752     0x9E5B: 0x6763,
5753     0x9E5C: 0x6764,
5754     0x9E5D: 0x6789,
5755     0x9E5E: 0x6770,
5756     0x9E5F: 0x67A9,
5757     0x9E60: 0x677C,
5758     0x9E61: 0x676A,
5759     0x9E62: 0x678C,
5760     0x9E63: 0x678B,
5761     0x9E64: 0x67A6,
5762     0x9E65: 0x67A1,
5763     0x9E66: 0x6785,
5764     0x9E67: 0x67B7,
5765     0x9E68: 0x67EF,
5766     0x9E69: 0x67B4,
5767     0x9E6A: 0x67EC,
5768     0x9E6B: 0x67B3,
5769     0x9E6C: 0x67E9,
5770     0x9E6D: 0x67B8,
5771     0x9E6E: 0x67E4,
5772     0x9E6F: 0x67DE,
5773     0x9E70: 0x67DD,
5774     0x9E71: 0x67E2,
5775     0x9E72: 0x67EE,
5776     0x9E73: 0x67B9,
5777     0x9E74: 0x67CE,
5778     0x9E75: 0x67C6,
5779     0x9E76: 0x67E7,
5780     0x9E77: 0x6A9C,
5781     0x9E78: 0x681E,
5782     0x9E79: 0x6846,
5783     0x9E7A: 0x6829,
5784     0x9E7B: 0x6840,
5785     0x9E7C: 0x684D,
5786     0x9E7D: 0x6832,
5787     0x9E7E: 0x684E,
5788     0x9E80: 0x68B3,
5789     0x9E81: 0x682B,
5790     0x9E82: 0x6859,
5791     0x9E83: 0x6863,
5792     0x9E84: 0x6877,
5793     0x9E85: 0x687F,
5794     0x9E86: 0x689F,
5795     0x9E87: 0x688F,
5796     0x9E88: 0x68AD,
5797     0x9E89: 0x6894,
5798     0x9E8A: 0x689D,
5799     0x9E8B: 0x689B,
5800     0x9E8C: 0x6883,
5801     0x9E8D: 0x6AAE,
5802     0x9E8E: 0x68B9,
5803     0x9E8F: 0x6874,
5804     0x9E90: 0x68B5,
5805     0x9E91: 0x68A0,
5806     0x9E92: 0x68BA,
5807     0x9E93: 0x690F,
5808     0x9E94: 0x688D,
5809     0x9E95: 0x687E,
5810     0x9E96: 0x6901,
5811     0x9E97: 0x68CA,
5812     0x9E98: 0x6908,
5813     0x9E99: 0x68D8,
5814     0x9E9A: 0x6922,
5815     0x9E9B: 0x6926,
5816     0x9E9C: 0x68E1,
5817     0x9E9D: 0x690C,
5818     0x9E9E: 0x68CD,
5819     0x9E9F: 0x68D4,
5820     0x9EA0: 0x68E7,
5821     0x9EA1: 0x68D5,
5822     0x9EA2: 0x6936,
5823     0x9EA3: 0x6912,
5824     0x9EA4: 0x6904,
5825     0x9EA5: 0x68D7,
5826     0x9EA6: 0x68E3,
5827     0x9EA7: 0x6925,
5828     0x9EA8: 0x68F9,
5829     0x9EA9: 0x68E0,
5830     0x9EAA: 0x68EF,
5831     0x9EAB: 0x6928,
5832     0x9EAC: 0x692A,
5833     0x9EAD: 0x691A,
5834     0x9EAE: 0x6923,
5835     0x9EAF: 0x6921,
5836     0x9EB0: 0x68C6,
5837     0x9EB1: 0x6979,
5838     0x9EB2: 0x6977,
5839     0x9EB3: 0x695C,
5840     0x9EB4: 0x6978,
5841     0x9EB5: 0x696B,
5842     0x9EB6: 0x6954,
5843     0x9EB7: 0x697E,
5844     0x9EB8: 0x696E,
5845     0x9EB9: 0x6939,
5846     0x9EBA: 0x6974,
5847     0x9EBB: 0x693D,
5848     0x9EBC: 0x6959,
5849     0x9EBD: 0x6930,
5850     0x9EBE: 0x6961,
5851     0x9EBF: 0x695E,
5852     0x9EC0: 0x695D,
5853     0x9EC1: 0x6981,
5854     0x9EC2: 0x696A,
5855     0x9EC3: 0x69B2,
5856     0x9EC4: 0x69AE,
5857     0x9EC5: 0x69D0,
5858     0x9EC6: 0x69BF,
5859     0x9EC7: 0x69C1,
5860     0x9EC8: 0x69D3,
5861     0x9EC9: 0x69BE,
5862     0x9ECA: 0x69CE,
5863     0x9ECB: 0x5BE8,
5864     0x9ECC: 0x69CA,
5865     0x9ECD: 0x69DD,
5866     0x9ECE: 0x69BB,
5867     0x9ECF: 0x69C3,
5868     0x9ED0: 0x69A7,
5869     0x9ED1: 0x6A2E,
5870     0x9ED2: 0x6991,
5871     0x9ED3: 0x69A0,
5872     0x9ED4: 0x699C,
5873     0x9ED5: 0x6995,
5874     0x9ED6: 0x69B4,
5875     0x9ED7: 0x69DE,
5876     0x9ED8: 0x69E8,
5877     0x9ED9: 0x6A02,
5878     0x9EDA: 0x6A1B,
5879     0x9EDB: 0x69FF,
5880     0x9EDC: 0x6B0A,
5881     0x9EDD: 0x69F9,
5882     0x9EDE: 0x69F2,
5883     0x9EDF: 0x69E7,
5884     0x9EE0: 0x6A05,
5885     0x9EE1: 0x69B1,
5886     0x9EE2: 0x6A1E,
5887     0x9EE3: 0x69ED,
5888     0x9EE4: 0x6A14,
5889     0x9EE5: 0x69EB,
5890     0x9EE6: 0x6A0A,
5891     0x9EE7: 0x6A12,
5892     0x9EE8: 0x6AC1,
5893     0x9EE9: 0x6A23,
5894     0x9EEA: 0x6A13,
5895     0x9EEB: 0x6A44,
5896     0x9EEC: 0x6A0C,
5897     0x9EED: 0x6A72,
5898     0x9EEE: 0x6A36,
5899     0x9EEF: 0x6A78,
5900     0x9EF0: 0x6A47,
5901     0x9EF1: 0x6A62,
5902     0x9EF2: 0x6A59,
5903     0x9EF3: 0x6A66,
5904     0x9EF4: 0x6A48,
5905     0x9EF5: 0x6A38,
5906     0x9EF6: 0x6A22,
5907     0x9EF7: 0x6A90,
5908     0x9EF8: 0x6A8D,
5909     0x9EF9: 0x6AA0,
5910     0x9EFA: 0x6A84,
5911     0x9EFB: 0x6AA2,
5912     0x9EFC: 0x6AA3,
5913     0x9F40: 0x6A97,
5914     0x9F41: 0x8617,
5915     0x9F42: 0x6ABB,
5916     0x9F43: 0x6AC3,
5917     0x9F44: 0x6AC2,
5918     0x9F45: 0x6AB8,
5919     0x9F46: 0x6AB3,
5920     0x9F47: 0x6AAC,
5921     0x9F48: 0x6ADE,
5922     0x9F49: 0x6AD1,
5923     0x9F4A: 0x6ADF,
5924     0x9F4B: 0x6AAA,
5925     0x9F4C: 0x6ADA,
5926     0x9F4D: 0x6AEA,
5927     0x9F4E: 0x6AFB,
5928     0x9F4F: 0x6B05,
5929     0x9F50: 0x8616,
5930     0x9F51: 0x6AFA,
5931     0x9F52: 0x6B12,
5932     0x9F53: 0x6B16,
5933     0x9F54: 0x9B31,
5934     0x9F55: 0x6B1F,
5935     0x9F56: 0x6B38,
5936     0x9F57: 0x6B37,
5937     0x9F58: 0x76DC,
5938     0x9F59: 0x6B39,
5939     0x9F5A: 0x98EE,
5940     0x9F5B: 0x6B47,
5941     0x9F5C: 0x6B43,
5942     0x9F5D: 0x6B49,
5943     0x9F5E: 0x6B50,
5944     0x9F5F: 0x6B59,
5945     0x9F60: 0x6B54,
5946     0x9F61: 0x6B5B,
5947     0x9F62: 0x6B5F,
5948     0x9F63: 0x6B61,
5949     0x9F64: 0x6B78,
5950     0x9F65: 0x6B79,
5951     0x9F66: 0x6B7F,
5952     0x9F67: 0x6B80,
5953     0x9F68: 0x6B84,
5954     0x9F69: 0x6B83,
5955     0x9F6A: 0x6B8D,
5956     0x9F6B: 0x6B98,
5957     0x9F6C: 0x6B95,
5958     0x9F6D: 0x6B9E,
5959     0x9F6E: 0x6BA4,
5960     0x9F6F: 0x6BAA,
5961     0x9F70: 0x6BAB,
5962     0x9F71: 0x6BAF,
5963     0x9F72: 0x6BB2,
5964     0x9F73: 0x6BB1,
5965     0x9F74: 0x6BB3,
5966     0x9F75: 0x6BB7,
5967     0x9F76: 0x6BBC,
5968     0x9F77: 0x6BC6,
5969     0x9F78: 0x6BCB,
5970     0x9F79: 0x6BD3,
5971     0x9F7A: 0x6BDF,
5972     0x9F7B: 0x6BEC,
5973     0x9F7C: 0x6BEB,
5974     0x9F7D: 0x6BF3,
5975     0x9F7E: 0x6BEF,
5976     0x9F80: 0x9EBE,
5977     0x9F81: 0x6C08,
5978     0x9F82: 0x6C13,
5979     0x9F83: 0x6C14,
5980     0x9F84: 0x6C1B,
5981     0x9F85: 0x6C24,
5982     0x9F86: 0x6C23,
5983     0x9F87: 0x6C5E,
5984     0x9F88: 0x6C55,
5985     0x9F89: 0x6C62,
5986     0x9F8A: 0x6C6A,
5987     0x9F8B: 0x6C82,
5988     0x9F8C: 0x6C8D,
5989     0x9F8D: 0x6C9A,
5990     0x9F8E: 0x6C81,
5991     0x9F8F: 0x6C9B,
5992     0x9F90: 0x6C7E,
5993     0x9F91: 0x6C68,
5994     0x9F92: 0x6C73,
5995     0x9F93: 0x6C92,
5996     0x9F94: 0x6C90,
5997     0x9F95: 0x6CC4,
5998     0x9F96: 0x6CF1,
5999     0x9F97: 0x6CD3,
6000     0x9F98: 0x6CBD,
6001     0x9F99: 0x6CD7,
6002     0x9F9A: 0x6CC5,
6003     0x9F9B: 0x6CDD,
6004     0x9F9C: 0x6CAE,
6005     0x9F9D: 0x6CB1,
6006     0x9F9E: 0x6CBE,
6007     0x9F9F: 0x6CBA,
6008     0x9FA0: 0x6CDB,
6009     0x9FA1: 0x6CEF,
6010     0x9FA2: 0x6CD9,
6011     0x9FA3: 0x6CEA,
6012     0x9FA4: 0x6D1F,
6013     0x9FA5: 0x884D,
6014     0x9FA6: 0x6D36,
6015     0x9FA7: 0x6D2B,
6016     0x9FA8: 0x6D3D,
6017     0x9FA9: 0x6D38,
6018     0x9FAA: 0x6D19,
6019     0x9FAB: 0x6D35,
6020     0x9FAC: 0x6D33,
6021     0x9FAD: 0x6D12,
6022     0x9FAE: 0x6D0C,
6023     0x9FAF: 0x6D63,
6024     0x9FB0: 0x6D93,
6025     0x9FB1: 0x6D64,
6026     0x9FB2: 0x6D5A,
6027     0x9FB3: 0x6D79,
6028     0x9FB4: 0x6D59,
6029     0x9FB5: 0x6D8E,
6030     0x9FB6: 0x6D95,
6031     0x9FB7: 0x6FE4,
6032     0x9FB8: 0x6D85,
6033     0x9FB9: 0x6DF9,
6034     0x9FBA: 0x6E15,
6035     0x9FBB: 0x6E0A,
6036     0x9FBC: 0x6DB5,
6037     0x9FBD: 0x6DC7,
6038     0x9FBE: 0x6DE6,
6039     0x9FBF: 0x6DB8,
6040     0x9FC0: 0x6DC6,
6041     0x9FC1: 0x6DEC,
6042     0x9FC2: 0x6DDE,
6043     0x9FC3: 0x6DCC,
6044     0x9FC4: 0x6DE8,
6045     0x9FC5: 0x6DD2,
6046     0x9FC6: 0x6DC5,
6047     0x9FC7: 0x6DFA,
6048     0x9FC8: 0x6DD9,
6049     0x9FC9: 0x6DE4,
6050     0x9FCA: 0x6DD5,
6051     0x9FCB: 0x6DEA,
6052     0x9FCC: 0x6DEE,
6053     0x9FCD: 0x6E2D,
6054     0x9FCE: 0x6E6E,
6055     0x9FCF: 0x6E2E,
6056     0x9FD0: 0x6E19,
6057     0x9FD1: 0x6E72,
6058     0x9FD2: 0x6E5F,
6059     0x9FD3: 0x6E3E,
6060     0x9FD4: 0x6E23,
6061     0x9FD5: 0x6E6B,
6062     0x9FD6: 0x6E2B,
6063     0x9FD7: 0x6E76,
6064     0x9FD8: 0x6E4D,
6065     0x9FD9: 0x6E1F,
6066     0x9FDA: 0x6E43,
6067     0x9FDB: 0x6E3A,
6068     0x9FDC: 0x6E4E,
6069     0x9FDD: 0x6E24,
6070     0x9FDE: 0x6EFF,
6071     0x9FDF: 0x6E1D,
6072     0x9FE0: 0x6E38,
6073     0x9FE1: 0x6E82,
6074     0x9FE2: 0x6EAA,
6075     0x9FE3: 0x6E98,
6076     0x9FE4: 0x6EC9,
6077     0x9FE5: 0x6EB7,
6078     0x9FE6: 0x6ED3,
6079     0x9FE7: 0x6EBD,
6080     0x9FE8: 0x6EAF,
6081     0x9FE9: 0x6EC4,
6082     0x9FEA: 0x6EB2,
6083     0x9FEB: 0x6ED4,
6084     0x9FEC: 0x6ED5,
6085     0x9FED: 0x6E8F,
6086     0x9FEE: 0x6EA5,
6087     0x9FEF: 0x6EC2,
6088     0x9FF0: 0x6E9F,
6089     0x9FF1: 0x6F41,
6090     0x9FF2: 0x6F11,
6091     0x9FF3: 0x704C,
6092     0x9FF4: 0x6EEC,
6093     0x9FF5: 0x6EF8,
6094     0x9FF6: 0x6EFE,
6095     0x9FF7: 0x6F3F,
6096     0x9FF8: 0x6EF2,
6097     0x9FF9: 0x6F31,
6098     0x9FFA: 0x6EEF,
6099     0x9FFB: 0x6F32,
6100     0x9FFC: 0x6ECC,
6101     0xA1: 0xFF61,
6102     0xA2: 0xFF62,
6103     0xA3: 0xFF63,
6104     0xA4: 0xFF64,
6105     0xA5: 0xFF65,
6106     0xA6: 0xFF66,
6107     0xA7: 0xFF67,
6108     0xA8: 0xFF68,
6109     0xA9: 0xFF69,
6110     0xAA: 0xFF6A,
6111     0xAB: 0xFF6B,
6112     0xAC: 0xFF6C,
6113     0xAD: 0xFF6D,
6114     0xAE: 0xFF6E,
6115     0xAF: 0xFF6F,
6116     0xB0: 0xFF70,
6117     0xB1: 0xFF71,
6118     0xB2: 0xFF72,
6119     0xB3: 0xFF73,
6120     0xB4: 0xFF74,
6121     0xB5: 0xFF75,
6122     0xB6: 0xFF76,
6123     0xB7: 0xFF77,
6124     0xB8: 0xFF78,
6125     0xB9: 0xFF79,
6126     0xBA: 0xFF7A,
6127     0xBB: 0xFF7B,
6128     0xBC: 0xFF7C,
6129     0xBD: 0xFF7D,
6130     0xBE: 0xFF7E,
6131     0xBF: 0xFF7F,
6132     0xC0: 0xFF80,
6133     0xC1: 0xFF81,
6134     0xC2: 0xFF82,
6135     0xC3: 0xFF83,
6136     0xC4: 0xFF84,
6137     0xC5: 0xFF85,
6138     0xC6: 0xFF86,
6139     0xC7: 0xFF87,
6140     0xC8: 0xFF88,
6141     0xC9: 0xFF89,
6142     0xCA: 0xFF8A,
6143     0xCB: 0xFF8B,
6144     0xCC: 0xFF8C,
6145     0xCD: 0xFF8D,
6146     0xCE: 0xFF8E,
6147     0xCF: 0xFF8F,
6148     0xD0: 0xFF90,
6149     0xD1: 0xFF91,
6150     0xD2: 0xFF92,
6151     0xD3: 0xFF93,
6152     0xD4: 0xFF94,
6153     0xD5: 0xFF95,
6154     0xD6: 0xFF96,
6155     0xD7: 0xFF97,
6156     0xD8: 0xFF98,
6157     0xD9: 0xFF99,
6158     0xDA: 0xFF9A,
6159     0xDB: 0xFF9B,
6160     0xDC: 0xFF9C,
6161     0xDD: 0xFF9D,
6162     0xDE: 0xFF9E,
6163     0xDF: 0xFF9F,
6164     0xE040: 0x6F3E,
6165     0xE041: 0x6F13,
6166     0xE042: 0x6EF7,
6167     0xE043: 0x6F86,
6168     0xE044: 0x6F7A,
6169     0xE045: 0x6F78,
6170     0xE046: 0x6F81,
6171     0xE047: 0x6F80,
6172     0xE048: 0x6F6F,
6173     0xE049: 0x6F5B,
6174     0xE04A: 0x6FF3,
6175     0xE04B: 0x6F6D,
6176     0xE04C: 0x6F82,
6177     0xE04D: 0x6F7C,
6178     0xE04E: 0x6F58,
6179     0xE04F: 0x6F8E,
6180     0xE050: 0x6F91,
6181     0xE051: 0x6FC2,
6182     0xE052: 0x6F66,
6183     0xE053: 0x6FB3,
6184     0xE054: 0x6FA3,
6185     0xE055: 0x6FA1,
6186     0xE056: 0x6FA4,
6187     0xE057: 0x6FB9,
6188     0xE058: 0x6FC6,
6189     0xE059: 0x6FAA,
6190     0xE05A: 0x6FDF,
6191     0xE05B: 0x6FD5,
6192     0xE05C: 0x6FEC,
6193     0xE05D: 0x6FD4,
6194     0xE05E: 0x6FD8,
6195     0xE05F: 0x6FF1,
6196     0xE060: 0x6FEE,
6197     0xE061: 0x6FDB,
6198     0xE062: 0x7009,
6199     0xE063: 0x700B,
6200     0xE064: 0x6FFA,
6201     0xE065: 0x7011,
6202     0xE066: 0x7001,
6203     0xE067: 0x700F,
6204     0xE068: 0x6FFE,
6205     0xE069: 0x701B,
6206     0xE06A: 0x701A,
6207     0xE06B: 0x6F74,
6208     0xE06C: 0x701D,
6209     0xE06D: 0x7018,
6210     0xE06E: 0x701F,
6211     0xE06F: 0x7030,
6212     0xE070: 0x703E,
6213     0xE071: 0x7032,
6214     0xE072: 0x7051,
6215     0xE073: 0x7063,
6216     0xE074: 0x7099,
6217     0xE075: 0x7092,
6218     0xE076: 0x70AF,
6219     0xE077: 0x70F1,
6220     0xE078: 0x70AC,
6221     0xE079: 0x70B8,
6222     0xE07A: 0x70B3,
6223     0xE07B: 0x70AE,
6224     0xE07C: 0x70DF,
6225     0xE07D: 0x70CB,
6226     0xE07E: 0x70DD,
6227     0xE080: 0x70D9,
6228     0xE081: 0x7109,
6229     0xE082: 0x70FD,
6230     0xE083: 0x711C,
6231     0xE084: 0x7119,
6232     0xE085: 0x7165,
6233     0xE086: 0x7155,
6234     0xE087: 0x7188,
6235     0xE088: 0x7166,
6236     0xE089: 0x7162,
6237     0xE08A: 0x714C,
6238     0xE08B: 0x7156,
6239     0xE08C: 0x716C,
6240     0xE08D: 0x718F,
6241     0xE08E: 0x71FB,
6242     0xE08F: 0x7184,
6243     0xE090: 0x7195,
6244     0xE091: 0x71A8,
6245     0xE092: 0x71AC,
6246     0xE093: 0x71D7,
6247     0xE094: 0x71B9,
6248     0xE095: 0x71BE,
6249     0xE096: 0x71D2,
6250     0xE097: 0x71C9,
6251     0xE098: 0x71D4,
6252     0xE099: 0x71CE,
6253     0xE09A: 0x71E0,
6254     0xE09B: 0x71EC,
6255     0xE09C: 0x71E7,
6256     0xE09D: 0x71F5,
6257     0xE09E: 0x71FC,
6258     0xE09F: 0x71F9,
6259     0xE0A0: 0x71FF,
6260     0xE0A1: 0x720D,
6261     0xE0A2: 0x7210,
6262     0xE0A3: 0x721B,
6263     0xE0A4: 0x7228,
6264     0xE0A5: 0x722D,
6265     0xE0A6: 0x722C,
6266     0xE0A7: 0x7230,
6267     0xE0A8: 0x7232,
6268     0xE0A9: 0x723B,
6269     0xE0AA: 0x723C,
6270     0xE0AB: 0x723F,
6271     0xE0AC: 0x7240,
6272     0xE0AD: 0x7246,
6273     0xE0AE: 0x724B,
6274     0xE0AF: 0x7258,
6275     0xE0B0: 0x7274,
6276     0xE0B1: 0x727E,
6277     0xE0B2: 0x7282,
6278     0xE0B3: 0x7281,
6279     0xE0B4: 0x7287,
6280     0xE0B5: 0x7292,
6281     0xE0B6: 0x7296,
6282     0xE0B7: 0x72A2,
6283     0xE0B8: 0x72A7,
6284     0xE0B9: 0x72B9,
6285     0xE0BA: 0x72B2,
6286     0xE0BB: 0x72C3,
6287     0xE0BC: 0x72C6,
6288     0xE0BD: 0x72C4,
6289     0xE0BE: 0x72CE,
6290     0xE0BF: 0x72D2,
6291     0xE0C0: 0x72E2,
6292     0xE0C1: 0x72E0,
6293     0xE0C2: 0x72E1,
6294     0xE0C3: 0x72F9,
6295     0xE0C4: 0x72F7,
6296     0xE0C5: 0x500F,
6297     0xE0C6: 0x7317,
6298     0xE0C7: 0x730A,
6299     0xE0C8: 0x731C,
6300     0xE0C9: 0x7316,
6301     0xE0CA: 0x731D,
6302     0xE0CB: 0x7334,
6303     0xE0CC: 0x732F,
6304     0xE0CD: 0x7329,
6305     0xE0CE: 0x7325,
6306     0xE0CF: 0x733E,
6307     0xE0D0: 0x734E,
6308     0xE0D1: 0x734F,
6309     0xE0D2: 0x9ED8,
6310     0xE0D3: 0x7357,
6311     0xE0D4: 0x736A,
6312     0xE0D5: 0x7368,
6313     0xE0D6: 0x7370,
6314     0xE0D7: 0x7378,
6315     0xE0D8: 0x7375,
6316     0xE0D9: 0x737B,
6317     0xE0DA: 0x737A,
6318     0xE0DB: 0x73C8,
6319     0xE0DC: 0x73B3,
6320     0xE0DD: 0x73CE,
6321     0xE0DE: 0x73BB,
6322     0xE0DF: 0x73C0,
6323     0xE0E0: 0x73E5,
6324     0xE0E1: 0x73EE,
6325     0xE0E2: 0x73DE,
6326     0xE0E3: 0x74A2,
6327     0xE0E4: 0x7405,
6328     0xE0E5: 0x746F,
6329     0xE0E6: 0x7425,
6330     0xE0E7: 0x73F8,
6331     0xE0E8: 0x7432,
6332     0xE0E9: 0x743A,
6333     0xE0EA: 0x7455,
6334     0xE0EB: 0x743F,
6335     0xE0EC: 0x745F,
6336     0xE0ED: 0x7459,
6337     0xE0EE: 0x7441,
6338     0xE0EF: 0x745C,
6339     0xE0F0: 0x7469,
6340     0xE0F1: 0x7470,
6341     0xE0F2: 0x7463,
6342     0xE0F3: 0x746A,
6343     0xE0F4: 0x7476,
6344     0xE0F5: 0x747E,
6345     0xE0F6: 0x748B,
6346     0xE0F7: 0x749E,
6347     0xE0F8: 0x74A7,
6348     0xE0F9: 0x74CA,
6349     0xE0FA: 0x74CF,
6350     0xE0FB: 0x74D4,
6351     0xE0FC: 0x73F1,
6352     0xE140: 0x74E0,
6353     0xE141: 0x74E3,
6354     0xE142: 0x74E7,
6355     0xE143: 0x74E9,
6356     0xE144: 0x74EE,
6357     0xE145: 0x74F2,
6358     0xE146: 0x74F0,
6359     0xE147: 0x74F1,
6360     0xE148: 0x74F8,
6361     0xE149: 0x74F7,
6362     0xE14A: 0x7504,
6363     0xE14B: 0x7503,
6364     0xE14C: 0x7505,
6365     0xE14D: 0x750C,
6366     0xE14E: 0x750E,
6367     0xE14F: 0x750D,
6368     0xE150: 0x7515,
6369     0xE151: 0x7513,
6370     0xE152: 0x751E,
6371     0xE153: 0x7526,
6372     0xE154: 0x752C,
6373     0xE155: 0x753C,
6374     0xE156: 0x7544,
6375     0xE157: 0x754D,
6376     0xE158: 0x754A,
6377     0xE159: 0x7549,
6378     0xE15A: 0x755B,
6379     0xE15B: 0x7546,
6380     0xE15C: 0x755A,
6381     0xE15D: 0x7569,
6382     0xE15E: 0x7564,
6383     0xE15F: 0x7567,
6384     0xE160: 0x756B,
6385     0xE161: 0x756D,
6386     0xE162: 0x7578,
6387     0xE163: 0x7576,
6388     0xE164: 0x7586,
6389     0xE165: 0x7587,
6390     0xE166: 0x7574,
6391     0xE167: 0x758A,
6392     0xE168: 0x7589,
6393     0xE169: 0x7582,
6394     0xE16A: 0x7594,
6395     0xE16B: 0x759A,
6396     0xE16C: 0x759D,
6397     0xE16D: 0x75A5,
6398     0xE16E: 0x75A3,
6399     0xE16F: 0x75C2,
6400     0xE170: 0x75B3,
6401     0xE171: 0x75C3,
6402     0xE172: 0x75B5,
6403     0xE173: 0x75BD,
6404     0xE174: 0x75B8,
6405     0xE175: 0x75BC,
6406     0xE176: 0x75B1,
6407     0xE177: 0x75CD,
6408     0xE178: 0x75CA,
6409     0xE179: 0x75D2,
6410     0xE17A: 0x75D9,
6411     0xE17B: 0x75E3,
6412     0xE17C: 0x75DE,
6413     0xE17D: 0x75FE,
6414     0xE17E: 0x75FF,
6415     0xE180: 0x75FC,
6416     0xE181: 0x7601,
6417     0xE182: 0x75F0,
6418     0xE183: 0x75FA,
6419     0xE184: 0x75F2,
6420     0xE185: 0x75F3,
6421     0xE186: 0x760B,
6422     0xE187: 0x760D,
6423     0xE188: 0x7609,
6424     0xE189: 0x761F,
6425     0xE18A: 0x7627,
6426     0xE18B: 0x7620,
6427     0xE18C: 0x7621,
6428     0xE18D: 0x7622,
6429     0xE18E: 0x7624,
6430     0xE18F: 0x7634,
6431     0xE190: 0x7630,
6432     0xE191: 0x763B,
6433     0xE192: 0x7647,
6434     0xE193: 0x7648,
6435     0xE194: 0x7646,
6436     0xE195: 0x765C,
6437     0xE196: 0x7658,
6438     0xE197: 0x7661,
6439     0xE198: 0x7662,
6440     0xE199: 0x7668,
6441     0xE19A: 0x7669,
6442     0xE19B: 0x766A,
6443     0xE19C: 0x7667,
6444     0xE19D: 0x766C,
6445     0xE19E: 0x7670,
6446     0xE19F: 0x7672,
6447     0xE1A0: 0x7676,
6448     0xE1A1: 0x7678,
6449     0xE1A2: 0x767C,
6450     0xE1A3: 0x7680,
6451     0xE1A4: 0x7683,
6452     0xE1A5: 0x7688,
6453     0xE1A6: 0x768B,
6454     0xE1A7: 0x768E,
6455     0xE1A8: 0x7696,
6456     0xE1A9: 0x7693,
6457     0xE1AA: 0x7699,
6458     0xE1AB: 0x769A,
6459     0xE1AC: 0x76B0,
6460     0xE1AD: 0x76B4,
6461     0xE1AE: 0x76B8,
6462     0xE1AF: 0x76B9,
6463     0xE1B0: 0x76BA,
6464     0xE1B1: 0x76C2,
6465     0xE1B2: 0x76CD,
6466     0xE1B3: 0x76D6,
6467     0xE1B4: 0x76D2,
6468     0xE1B5: 0x76DE,
6469     0xE1B6: 0x76E1,
6470     0xE1B7: 0x76E5,
6471     0xE1B8: 0x76E7,
6472     0xE1B9: 0x76EA,
6473     0xE1BA: 0x862F,
6474     0xE1BB: 0x76FB,
6475     0xE1BC: 0x7708,
6476     0xE1BD: 0x7707,
6477     0xE1BE: 0x7704,
6478     0xE1BF: 0x7729,
6479     0xE1C0: 0x7724,
6480     0xE1C1: 0x771E,
6481     0xE1C2: 0x7725,
6482     0xE1C3: 0x7726,
6483     0xE1C4: 0x771B,
6484     0xE1C5: 0x7737,
6485     0xE1C6: 0x7738,
6486     0xE1C7: 0x7747,
6487     0xE1C8: 0x775A,
6488     0xE1C9: 0x7768,
6489     0xE1CA: 0x776B,
6490     0xE1CB: 0x775B,
6491     0xE1CC: 0x7765,
6492     0xE1CD: 0x777F,
6493     0xE1CE: 0x777E,
6494     0xE1CF: 0x7779,
6495     0xE1D0: 0x778E,
6496     0xE1D1: 0x778B,
6497     0xE1D2: 0x7791,
6498     0xE1D3: 0x77A0,
6499     0xE1D4: 0x779E,
6500     0xE1D5: 0x77B0,
6501     0xE1D6: 0x77B6,
6502     0xE1D7: 0x77B9,
6503     0xE1D8: 0x77BF,
6504     0xE1D9: 0x77BC,
6505     0xE1DA: 0x77BD,
6506     0xE1DB: 0x77BB,
6507     0xE1DC: 0x77C7,
6508     0xE1DD: 0x77CD,
6509     0xE1DE: 0x77D7,
6510     0xE1DF: 0x77DA,
6511     0xE1E0: 0x77DC,
6512     0xE1E1: 0x77E3,
6513     0xE1E2: 0x77EE,
6514     0xE1E3: 0x77FC,
6515     0xE1E4: 0x780C,
6516     0xE1E5: 0x7812,
6517     0xE1E6: 0x7926,
6518     0xE1E7: 0x7820,
6519     0xE1E8: 0x792A,
6520     0xE1E9: 0x7845,
6521     0xE1EA: 0x788E,
6522     0xE1EB: 0x7874,
6523     0xE1EC: 0x7886,
6524     0xE1ED: 0x787C,
6525     0xE1EE: 0x789A,
6526     0xE1EF: 0x788C,
6527     0xE1F0: 0x78A3,
6528     0xE1F1: 0x78B5,
6529     0xE1F2: 0x78AA,
6530     0xE1F3: 0x78AF,
6531     0xE1F4: 0x78D1,
6532     0xE1F5: 0x78C6,
6533     0xE1F6: 0x78CB,
6534     0xE1F7: 0x78D4,
6535     0xE1F8: 0x78BE,
6536     0xE1F9: 0x78BC,
6537     0xE1FA: 0x78C5,
6538     0xE1FB: 0x78CA,
6539     0xE1FC: 0x78EC,
6540     0xE240: 0x78E7,
6541     0xE241: 0x78DA,
6542     0xE242: 0x78FD,
6543     0xE243: 0x78F4,
6544     0xE244: 0x7907,
6545     0xE245: 0x7912,
6546     0xE246: 0x7911,
6547     0xE247: 0x7919,
6548     0xE248: 0x792C,
6549     0xE249: 0x792B,
6550     0xE24A: 0x7940,
6551     0xE24B: 0x7960,
6552     0xE24C: 0x7957,
6553     0xE24D: 0x795F,
6554     0xE24E: 0x795A,
6555     0xE24F: 0x7955,
6556     0xE250: 0x7953,
6557     0xE251: 0x797A,
6558     0xE252: 0x797F,
6559     0xE253: 0x798A,
6560     0xE254: 0x799D,
6561     0xE255: 0x79A7,
6562     0xE256: 0x9F4B,
6563     0xE257: 0x79AA,
6564     0xE258: 0x79AE,
6565     0xE259: 0x79B3,
6566     0xE25A: 0x79B9,
6567     0xE25B: 0x79BA,
6568     0xE25C: 0x79C9,
6569     0xE25D: 0x79D5,
6570     0xE25E: 0x79E7,
6571     0xE25F: 0x79EC,
6572     0xE260: 0x79E1,
6573     0xE261: 0x79E3,
6574     0xE262: 0x7A08,
6575     0xE263: 0x7A0D,
6576     0xE264: 0x7A18,
6577     0xE265: 0x7A19,
6578     0xE266: 0x7A20,
6579     0xE267: 0x7A1F,
6580     0xE268: 0x7980,
6581     0xE269: 0x7A31,
6582     0xE26A: 0x7A3B,
6583     0xE26B: 0x7A3E,
6584     0xE26C: 0x7A37,
6585     0xE26D: 0x7A43,
6586     0xE26E: 0x7A57,
6587     0xE26F: 0x7A49,
6588     0xE270: 0x7A61,
6589     0xE271: 0x7A62,
6590     0xE272: 0x7A69,
6591     0xE273: 0x9F9D,
6592     0xE274: 0x7A70,
6593     0xE275: 0x7A79,
6594     0xE276: 0x7A7D,
6595     0xE277: 0x7A88,
6596     0xE278: 0x7A97,
6597     0xE279: 0x7A95,
6598     0xE27A: 0x7A98,
6599     0xE27B: 0x7A96,
6600     0xE27C: 0x7AA9,
6601     0xE27D: 0x7AC8,
6602     0xE27E: 0x7AB0,
6603     0xE280: 0x7AB6,
6604     0xE281: 0x7AC5,
6605     0xE282: 0x7AC4,
6606     0xE283: 0x7ABF,
6607     0xE284: 0x9083,
6608     0xE285: 0x7AC7,
6609     0xE286: 0x7ACA,
6610     0xE287: 0x7ACD,
6611     0xE288: 0x7ACF,
6612     0xE289: 0x7AD5,
6613     0xE28A: 0x7AD3,
6614     0xE28B: 0x7AD9,
6615     0xE28C: 0x7ADA,
6616     0xE28D: 0x7ADD,
6617     0xE28E: 0x7AE1,
6618     0xE28F: 0x7AE2,
6619     0xE290: 0x7AE6,
6620     0xE291: 0x7AED,
6621     0xE292: 0x7AF0,
6622     0xE293: 0x7B02,
6623     0xE294: 0x7B0F,
6624     0xE295: 0x7B0A,
6625     0xE296: 0x7B06,
6626     0xE297: 0x7B33,
6627     0xE298: 0x7B18,
6628     0xE299: 0x7B19,
6629     0xE29A: 0x7B1E,
6630     0xE29B: 0x7B35,
6631     0xE29C: 0x7B28,
6632     0xE29D: 0x7B36,
6633     0xE29E: 0x7B50,
6634     0xE29F: 0x7B7A,
6635     0xE2A0: 0x7B04,
6636     0xE2A1: 0x7B4D,
6637     0xE2A2: 0x7B0B,
6638     0xE2A3: 0x7B4C,
6639     0xE2A4: 0x7B45,
6640     0xE2A5: 0x7B75,
6641     0xE2A6: 0x7B65,
6642     0xE2A7: 0x7B74,
6643     0xE2A8: 0x7B67,
6644     0xE2A9: 0x7B70,
6645     0xE2AA: 0x7B71,
6646     0xE2AB: 0x7B6C,
6647     0xE2AC: 0x7B6E,
6648     0xE2AD: 0x7B9D,
6649     0xE2AE: 0x7B98,
6650     0xE2AF: 0x7B9F,
6651     0xE2B0: 0x7B8D,
6652     0xE2B1: 0x7B9C,
6653     0xE2B2: 0x7B9A,
6654     0xE2B3: 0x7B8B,
6655     0xE2B4: 0x7B92,
6656     0xE2B5: 0x7B8F,
6657     0xE2B6: 0x7B5D,
6658     0xE2B7: 0x7B99,
6659     0xE2B8: 0x7BCB,
6660     0xE2B9: 0x7BC1,
6661     0xE2BA: 0x7BCC,
6662     0xE2BB: 0x7BCF,
6663     0xE2BC: 0x7BB4,
6664     0xE2BD: 0x7BC6,
6665     0xE2BE: 0x7BDD,
6666     0xE2BF: 0x7BE9,
6667     0xE2C0: 0x7C11,
6668     0xE2C1: 0x7C14,
6669     0xE2C2: 0x7BE6,
6670     0xE2C3: 0x7BE5,
6671     0xE2C4: 0x7C60,
6672     0xE2C5: 0x7C00,
6673     0xE2C6: 0x7C07,
6674     0xE2C7: 0x7C13,
6675     0xE2C8: 0x7BF3,
6676     0xE2C9: 0x7BF7,
6677     0xE2CA: 0x7C17,
6678     0xE2CB: 0x7C0D,
6679     0xE2CC: 0x7BF6,
6680     0xE2CD: 0x7C23,
6681     0xE2CE: 0x7C27,
6682     0xE2CF: 0x7C2A,
6683     0xE2D0: 0x7C1F,
6684     0xE2D1: 0x7C37,
6685     0xE2D2: 0x7C2B,
6686     0xE2D3: 0x7C3D,
6687     0xE2D4: 0x7C4C,
6688     0xE2D5: 0x7C43,
6689     0xE2D6: 0x7C54,
6690     0xE2D7: 0x7C4F,
6691     0xE2D8: 0x7C40,
6692     0xE2D9: 0x7C50,
6693     0xE2DA: 0x7C58,
6694     0xE2DB: 0x7C5F,
6695     0xE2DC: 0x7C64,
6696     0xE2DD: 0x7C56,
6697     0xE2DE: 0x7C65,
6698     0xE2DF: 0x7C6C,
6699     0xE2E0: 0x7C75,
6700     0xE2E1: 0x7C83,
6701     0xE2E2: 0x7C90,
6702     0xE2E3: 0x7CA4,
6703     0xE2E4: 0x7CAD,
6704     0xE2E5: 0x7CA2,
6705     0xE2E6: 0x7CAB,
6706     0xE2E7: 0x7CA1,
6707     0xE2E8: 0x7CA8,
6708     0xE2E9: 0x7CB3,
6709     0xE2EA: 0x7CB2,
6710     0xE2EB: 0x7CB1,
6711     0xE2EC: 0x7CAE,
6712     0xE2ED: 0x7CB9,
6713     0xE2EE: 0x7CBD,
6714     0xE2EF: 0x7CC0,
6715     0xE2F0: 0x7CC5,
6716     0xE2F1: 0x7CC2,
6717     0xE2F2: 0x7CD8,
6718     0xE2F3: 0x7CD2,
6719     0xE2F4: 0x7CDC,
6720     0xE2F5: 0x7CE2,
6721     0xE2F6: 0x9B3B,
6722     0xE2F7: 0x7CEF,
6723     0xE2F8: 0x7CF2,
6724     0xE2F9: 0x7CF4,
6725     0xE2FA: 0x7CF6,
6726     0xE2FB: 0x7CFA,
6727     0xE2FC: 0x7D06,
6728     0xE340: 0x7D02,
6729     0xE341: 0x7D1C,
6730     0xE342: 0x7D15,
6731     0xE343: 0x7D0A,
6732     0xE344: 0x7D45,
6733     0xE345: 0x7D4B,
6734     0xE346: 0x7D2E,
6735     0xE347: 0x7D32,
6736     0xE348: 0x7D3F,
6737     0xE349: 0x7D35,
6738     0xE34A: 0x7D46,
6739     0xE34B: 0x7D73,
6740     0xE34C: 0x7D56,
6741     0xE34D: 0x7D4E,
6742     0xE34E: 0x7D72,
6743     0xE34F: 0x7D68,
6744     0xE350: 0x7D6E,
6745     0xE351: 0x7D4F,
6746     0xE352: 0x7D63,
6747     0xE353: 0x7D93,
6748     0xE354: 0x7D89,
6749     0xE355: 0x7D5B,
6750     0xE356: 0x7D8F,
6751     0xE357: 0x7D7D,
6752     0xE358: 0x7D9B,
6753     0xE359: 0x7DBA,
6754     0xE35A: 0x7DAE,
6755     0xE35B: 0x7DA3,
6756     0xE35C: 0x7DB5,
6757     0xE35D: 0x7DC7,
6758     0xE35E: 0x7DBD,
6759     0xE35F: 0x7DAB,
6760     0xE360: 0x7E3D,
6761     0xE361: 0x7DA2,
6762     0xE362: 0x7DAF,
6763     0xE363: 0x7DDC,
6764     0xE364: 0x7DB8,
6765     0xE365: 0x7D9F,
6766     0xE366: 0x7DB0,
6767     0xE367: 0x7DD8,
6768     0xE368: 0x7DDD,
6769     0xE369: 0x7DE4,
6770     0xE36A: 0x7DDE,
6771     0xE36B: 0x7DFB,
6772     0xE36C: 0x7DF2,
6773     0xE36D: 0x7DE1,
6774     0xE36E: 0x7E05,
6775     0xE36F: 0x7E0A,
6776     0xE370: 0x7E23,
6777     0xE371: 0x7E21,
6778     0xE372: 0x7E12,
6779     0xE373: 0x7E31,
6780     0xE374: 0x7E1F,
6781     0xE375: 0x7E09,
6782     0xE376: 0x7E0B,
6783     0xE377: 0x7E22,
6784     0xE378: 0x7E46,
6785     0xE379: 0x7E66,
6786     0xE37A: 0x7E3B,
6787     0xE37B: 0x7E35,
6788     0xE37C: 0x7E39,
6789     0xE37D: 0x7E43,
6790     0xE37E: 0x7E37,
6791     0xE380: 0x7E32,
6792     0xE381: 0x7E3A,
6793     0xE382: 0x7E67,
6794     0xE383: 0x7E5D,
6795     0xE384: 0x7E56,
6796     0xE385: 0x7E5E,
6797     0xE386: 0x7E59,
6798     0xE387: 0x7E5A,
6799     0xE388: 0x7E79,
6800     0xE389: 0x7E6A,
6801     0xE38A: 0x7E69,
6802     0xE38B: 0x7E7C,
6803     0xE38C: 0x7E7B,
6804     0xE38D: 0x7E83,
6805     0xE38E: 0x7DD5,
6806     0xE38F: 0x7E7D,
6807     0xE390: 0x8FAE,
6808     0xE391: 0x7E7F,
6809     0xE392: 0x7E88,
6810     0xE393: 0x7E89,
6811     0xE394: 0x7E8C,
6812     0xE395: 0x7E92,
6813     0xE396: 0x7E90,
6814     0xE397: 0x7E93,
6815     0xE398: 0x7E94,
6816     0xE399: 0x7E96,
6817     0xE39A: 0x7E8E,
6818     0xE39B: 0x7E9B,
6819     0xE39C: 0x7E9C,
6820     0xE39D: 0x7F38,
6821     0xE39E: 0x7F3A,
6822     0xE39F: 0x7F45,
6823     0xE3A0: 0x7F4C,
6824     0xE3A1: 0x7F4D,
6825     0xE3A2: 0x7F4E,
6826     0xE3A3: 0x7F50,
6827     0xE3A4: 0x7F51,
6828     0xE3A5: 0x7F55,
6829     0xE3A6: 0x7F54,
6830     0xE3A7: 0x7F58,
6831     0xE3A8: 0x7F5F,
6832     0xE3A9: 0x7F60,
6833     0xE3AA: 0x7F68,
6834     0xE3AB: 0x7F69,
6835     0xE3AC: 0x7F67,
6836     0xE3AD: 0x7F78,
6837     0xE3AE: 0x7F82,
6838     0xE3AF: 0x7F86,
6839     0xE3B0: 0x7F83,
6840     0xE3B1: 0x7F88,
6841     0xE3B2: 0x7F87,
6842     0xE3B3: 0x7F8C,
6843     0xE3B4: 0x7F94,
6844     0xE3B5: 0x7F9E,
6845     0xE3B6: 0x7F9D,
6846     0xE3B7: 0x7F9A,
6847     0xE3B8: 0x7FA3,
6848     0xE3B9: 0x7FAF,
6849     0xE3BA: 0x7FB2,
6850     0xE3BB: 0x7FB9,
6851     0xE3BC: 0x7FAE,
6852     0xE3BD: 0x7FB6,
6853     0xE3BE: 0x7FB8,
6854     0xE3BF: 0x8B71,
6855     0xE3C0: 0x7FC5,
6856     0xE3C1: 0x7FC6,
6857     0xE3C2: 0x7FCA,
6858     0xE3C3: 0x7FD5,
6859     0xE3C4: 0x7FD4,
6860     0xE3C5: 0x7FE1,
6861     0xE3C6: 0x7FE6,
6862     0xE3C7: 0x7FE9,
6863     0xE3C8: 0x7FF3,
6864     0xE3C9: 0x7FF9,
6865     0xE3CA: 0x98DC,
6866     0xE3CB: 0x8006,
6867     0xE3CC: 0x8004,
6868     0xE3CD: 0x800B,
6869     0xE3CE: 0x8012,
6870     0xE3CF: 0x8018,
6871     0xE3D0: 0x8019,
6872     0xE3D1: 0x801C,
6873     0xE3D2: 0x8021,
6874     0xE3D3: 0x8028,
6875     0xE3D4: 0x803F,
6876     0xE3D5: 0x803B,
6877     0xE3D6: 0x804A,
6878     0xE3D7: 0x8046,
6879     0xE3D8: 0x8052,
6880     0xE3D9: 0x8058,
6881     0xE3DA: 0x805A,
6882     0xE3DB: 0x805F,
6883     0xE3DC: 0x8062,
6884     0xE3DD: 0x8068,
6885     0xE3DE: 0x8073,
6886     0xE3DF: 0x8072,
6887     0xE3E0: 0x8070,
6888     0xE3E1: 0x8076,
6889     0xE3E2: 0x8079,
6890     0xE3E3: 0x807D,
6891     0xE3E4: 0x807F,
6892     0xE3E5: 0x8084,
6893     0xE3E6: 0x8086,
6894     0xE3E7: 0x8085,
6895     0xE3E8: 0x809B,
6896     0xE3E9: 0x8093,
6897     0xE3EA: 0x809A,
6898     0xE3EB: 0x80AD,
6899     0xE3EC: 0x5190,
6900     0xE3ED: 0x80AC,
6901     0xE3EE: 0x80DB,
6902     0xE3EF: 0x80E5,
6903     0xE3F0: 0x80D9,
6904     0xE3F1: 0x80DD,
6905     0xE3F2: 0x80C4,
6906     0xE3F3: 0x80DA,
6907     0xE3F4: 0x80D6,
6908     0xE3F5: 0x8109,
6909     0xE3F6: 0x80EF,
6910     0xE3F7: 0x80F1,
6911     0xE3F8: 0x811B,
6912     0xE3F9: 0x8129,
6913     0xE3FA: 0x8123,
6914     0xE3FB: 0x812F,
6915     0xE3FC: 0x814B,
6916     0xE440: 0x968B,
6917     0xE441: 0x8146,
6918     0xE442: 0x813E,
6919     0xE443: 0x8153,
6920     0xE444: 0x8151,
6921     0xE445: 0x80FC,
6922     0xE446: 0x8171,
6923     0xE447: 0x816E,
6924     0xE448: 0x8165,
6925     0xE449: 0x8166,
6926     0xE44A: 0x8174,
6927     0xE44B: 0x8183,
6928     0xE44C: 0x8188,
6929     0xE44D: 0x818A,
6930     0xE44E: 0x8180,
6931     0xE44F: 0x8182,
6932     0xE450: 0x81A0,
6933     0xE451: 0x8195,
6934     0xE452: 0x81A4,
6935     0xE453: 0x81A3,
6936     0xE454: 0x815F,
6937     0xE455: 0x8193,
6938     0xE456: 0x81A9,
6939     0xE457: 0x81B0,
6940     0xE458: 0x81B5,
6941     0xE459: 0x81BE,
6942     0xE45A: 0x81B8,
6943     0xE45B: 0x81BD,
6944     0xE45C: 0x81C0,
6945     0xE45D: 0x81C2,
6946     0xE45E: 0x81BA,
6947     0xE45F: 0x81C9,
6948     0xE460: 0x81CD,
6949     0xE461: 0x81D1,
6950     0xE462: 0x81D9,
6951     0xE463: 0x81D8,
6952     0xE464: 0x81C8,
6953     0xE465: 0x81DA,
6954     0xE466: 0x81DF,
6955     0xE467: 0x81E0,
6956     0xE468: 0x81E7,
6957     0xE469: 0x81FA,
6958     0xE46A: 0x81FB,
6959     0xE46B: 0x81FE,
6960     0xE46C: 0x8201,
6961     0xE46D: 0x8202,
6962     0xE46E: 0x8205,
6963     0xE46F: 0x8207,
6964     0xE470: 0x820A,
6965     0xE471: 0x820D,
6966     0xE472: 0x8210,
6967     0xE473: 0x8216,
6968     0xE474: 0x8229,
6969     0xE475: 0x822B,
6970     0xE476: 0x8238,
6971     0xE477: 0x8233,
6972     0xE478: 0x8240,
6973     0xE479: 0x8259,
6974     0xE47A: 0x8258,
6975     0xE47B: 0x825D,
6976     0xE47C: 0x825A,
6977     0xE47D: 0x825F,
6978     0xE47E: 0x8264,
6979     0xE480: 0x8262,
6980     0xE481: 0x8268,
6981     0xE482: 0x826A,
6982     0xE483: 0x826B,
6983     0xE484: 0x822E,
6984     0xE485: 0x8271,
6985     0xE486: 0x8277,
6986     0xE487: 0x8278,
6987     0xE488: 0x827E,
6988     0xE489: 0x828D,
6989     0xE48A: 0x8292,
6990     0xE48B: 0x82AB,
6991     0xE48C: 0x829F,
6992     0xE48D: 0x82BB,
6993     0xE48E: 0x82AC,
6994     0xE48F: 0x82E1,
6995     0xE490: 0x82E3,
6996     0xE491: 0x82DF,
6997     0xE492: 0x82D2,
6998     0xE493: 0x82F4,
6999     0xE494: 0x82F3,
7000     0xE495: 0x82FA,
7001     0xE496: 0x8393,
7002     0xE497: 0x8303,
7003     0xE498: 0x82FB,
7004     0xE499: 0x82F9,
7005     0xE49A: 0x82DE,
7006     0xE49B: 0x8306,
7007     0xE49C: 0x82DC,
7008     0xE49D: 0x8309,
7009     0xE49E: 0x82D9,
7010     0xE49F: 0x8335,
7011     0xE4A0: 0x8334,
7012     0xE4A1: 0x8316,
7013     0xE4A2: 0x8332,
7014     0xE4A3: 0x8331,
7015     0xE4A4: 0x8340,
7016     0xE4A5: 0x8339,
7017     0xE4A6: 0x8350,
7018     0xE4A7: 0x8345,
7019     0xE4A8: 0x832F,
7020     0xE4A9: 0x832B,
7021     0xE4AA: 0x8317,
7022     0xE4AB: 0x8318,
7023     0xE4AC: 0x8385,
7024     0xE4AD: 0x839A,
7025     0xE4AE: 0x83AA,
7026     0xE4AF: 0x839F,
7027     0xE4B0: 0x83A2,
7028     0xE4B1: 0x8396,
7029     0xE4B2: 0x8323,
7030     0xE4B3: 0x838E,
7031     0xE4B4: 0x8387,
7032     0xE4B5: 0x838A,
7033     0xE4B6: 0x837C,
7034     0xE4B7: 0x83B5,
7035     0xE4B8: 0x8373,
7036     0xE4B9: 0x8375,
7037     0xE4BA: 0x83A0,
7038     0xE4BB: 0x8389,
7039     0xE4BC: 0x83A8,
7040     0xE4BD: 0x83F4,
7041     0xE4BE: 0x8413,
7042     0xE4BF: 0x83EB,
7043     0xE4C0: 0x83CE,
7044     0xE4C1: 0x83FD,
7045     0xE4C2: 0x8403,
7046     0xE4C3: 0x83D8,
7047     0xE4C4: 0x840B,
7048     0xE4C5: 0x83C1,
7049     0xE4C6: 0x83F7,
7050     0xE4C7: 0x8407,
7051     0xE4C8: 0x83E0,
7052     0xE4C9: 0x83F2,
7053     0xE4CA: 0x840D,
7054     0xE4CB: 0x8422,
7055     0xE4CC: 0x8420,
7056     0xE4CD: 0x83BD,
7057     0xE4CE: 0x8438,
7058     0xE4CF: 0x8506,
7059     0xE4D0: 0x83FB,
7060     0xE4D1: 0x846D,
7061     0xE4D2: 0x842A,
7062     0xE4D3: 0x843C,
7063     0xE4D4: 0x855A,
7064     0xE4D5: 0x8484,
7065     0xE4D6: 0x8477,
7066     0xE4D7: 0x846B,
7067     0xE4D8: 0x84AD,
7068     0xE4D9: 0x846E,
7069     0xE4DA: 0x8482,
7070     0xE4DB: 0x8469,
7071     0xE4DC: 0x8446,
7072     0xE4DD: 0x842C,
7073     0xE4DE: 0x846F,
7074     0xE4DF: 0x8479,
7075     0xE4E0: 0x8435,
7076     0xE4E1: 0x84CA,
7077     0xE4E2: 0x8462,
7078     0xE4E3: 0x84B9,
7079     0xE4E4: 0x84BF,
7080     0xE4E5: 0x849F,
7081     0xE4E6: 0x84D9,
7082     0xE4E7: 0x84CD,
7083     0xE4E8: 0x84BB,
7084     0xE4E9: 0x84DA,
7085     0xE4EA: 0x84D0,
7086     0xE4EB: 0x84C1,
7087     0xE4EC: 0x84C6,
7088     0xE4ED: 0x84D6,
7089     0xE4EE: 0x84A1,
7090     0xE4EF: 0x8521,
7091     0xE4F0: 0x84FF,
7092     0xE4F1: 0x84F4,
7093     0xE4F2: 0x8517,
7094     0xE4F3: 0x8518,
7095     0xE4F4: 0x852C,
7096     0xE4F5: 0x851F,
7097     0xE4F6: 0x8515,
7098     0xE4F7: 0x8514,
7099     0xE4F8: 0x84FC,
7100     0xE4F9: 0x8540,
7101     0xE4FA: 0x8563,
7102     0xE4FB: 0x8558,
7103     0xE4FC: 0x8548,
7104     0xE540: 0x8541,
7105     0xE541: 0x8602,
7106     0xE542: 0x854B,
7107     0xE543: 0x8555,
7108     0xE544: 0x8580,
7109     0xE545: 0x85A4,
7110     0xE546: 0x8588,
7111     0xE547: 0x8591,
7112     0xE548: 0x858A,
7113     0xE549: 0x85A8,
7114     0xE54A: 0x856D,
7115     0xE54B: 0x8594,
7116     0xE54C: 0x859B,
7117     0xE54D: 0x85EA,
7118     0xE54E: 0x8587,
7119     0xE54F: 0x859C,
7120     0xE550: 0x8577,
7121     0xE551: 0x857E,
7122     0xE552: 0x8590,
7123     0xE553: 0x85C9,
7124     0xE554: 0x85BA,
7125     0xE555: 0x85CF,
7126     0xE556: 0x85B9,
7127     0xE557: 0x85D0,
7128     0xE558: 0x85D5,
7129     0xE559: 0x85DD,
7130     0xE55A: 0x85E5,
7131     0xE55B: 0x85DC,
7132     0xE55C: 0x85F9,
7133     0xE55D: 0x860A,
7134     0xE55E: 0x8613,
7135     0xE55F: 0x860B,
7136     0xE560: 0x85FE,
7137     0xE561: 0x85FA,
7138     0xE562: 0x8606,
7139     0xE563: 0x8622,
7140     0xE564: 0x861A,
7141     0xE565: 0x8630,
7142     0xE566: 0x863F,
7143     0xE567: 0x864D,
7144     0xE568: 0x4E55,
7145     0xE569: 0x8654,
7146     0xE56A: 0x865F,
7147     0xE56B: 0x8667,
7148     0xE56C: 0x8671,
7149     0xE56D: 0x8693,
7150     0xE56E: 0x86A3,
7151     0xE56F: 0x86A9,
7152     0xE570: 0x86AA,
7153     0xE571: 0x868B,
7154     0xE572: 0x868C,
7155     0xE573: 0x86B6,
7156     0xE574: 0x86AF,
7157     0xE575: 0x86C4,
7158     0xE576: 0x86C6,
7159     0xE577: 0x86B0,
7160     0xE578: 0x86C9,
7161     0xE579: 0x8823,
7162     0xE57A: 0x86AB,
7163     0xE57B: 0x86D4,
7164     0xE57C: 0x86DE,
7165     0xE57D: 0x86E9,
7166     0xE57E: 0x86EC,
7167     0xE580: 0x86DF,
7168     0xE581: 0x86DB,
7169     0xE582: 0x86EF,
7170     0xE583: 0x8712,
7171     0xE584: 0x8706,
7172     0xE585: 0x8708,
7173     0xE586: 0x8700,
7174     0xE587: 0x8703,
7175     0xE588: 0x86FB,
7176     0xE589: 0x8711,
7177     0xE58A: 0x8709,
7178     0xE58B: 0x870D,
7179     0xE58C: 0x86F9,
7180     0xE58D: 0x870A,
7181     0xE58E: 0x8734,
7182     0xE58F: 0x873F,
7183     0xE590: 0x8737,
7184     0xE591: 0x873B,
7185     0xE592: 0x8725,
7186     0xE593: 0x8729,
7187     0xE594: 0x871A,
7188     0xE595: 0x8760,
7189     0xE596: 0x875F,
7190     0xE597: 0x8778,
7191     0xE598: 0x874C,
7192     0xE599: 0x874E,
7193     0xE59A: 0x8774,
7194     0xE59B: 0x8757,
7195     0xE59C: 0x8768,
7196     0xE59D: 0x876E,
7197     0xE59E: 0x8759,
7198     0xE59F: 0x8753,
7199     0xE5A0: 0x8763,
7200     0xE5A1: 0x876A,
7201     0xE5A2: 0x8805,
7202     0xE5A3: 0x87A2,
7203     0xE5A4: 0x879F,
7204     0xE5A5: 0x8782,
7205     0xE5A6: 0x87AF,
7206     0xE5A7: 0x87CB,
7207     0xE5A8: 0x87BD,
7208     0xE5A9: 0x87C0,
7209     0xE5AA: 0x87D0,
7210     0xE5AB: 0x96D6,
7211     0xE5AC: 0x87AB,
7212     0xE5AD: 0x87C4,
7213     0xE5AE: 0x87B3,
7214     0xE5AF: 0x87C7,
7215     0xE5B0: 0x87C6,
7216     0xE5B1: 0x87BB,
7217     0xE5B2: 0x87EF,
7218     0xE5B3: 0x87F2,
7219     0xE5B4: 0x87E0,
7220     0xE5B5: 0x880F,
7221     0xE5B6: 0x880D,
7222     0xE5B7: 0x87FE,
7223     0xE5B8: 0x87F6,
7224     0xE5B9: 0x87F7,
7225     0xE5BA: 0x880E,
7226     0xE5BB: 0x87D2,
7227     0xE5BC: 0x8811,
7228     0xE5BD: 0x8816,
7229     0xE5BE: 0x8815,
7230     0xE5BF: 0x8822,
7231     0xE5C0: 0x8821,
7232     0xE5C1: 0x8831,
7233     0xE5C2: 0x8836,
7234     0xE5C3: 0x8839,
7235     0xE5C4: 0x8827,
7236     0xE5C5: 0x883B,
7237     0xE5C6: 0x8844,
7238     0xE5C7: 0x8842,
7239     0xE5C8: 0x8852,
7240     0xE5C9: 0x8859,
7241     0xE5CA: 0x885E,
7242     0xE5CB: 0x8862,
7243     0xE5CC: 0x886B,
7244     0xE5CD: 0x8881,
7245     0xE5CE: 0x887E,
7246     0xE5CF: 0x889E,
7247     0xE5D0: 0x8875,
7248     0xE5D1: 0x887D,
7249     0xE5D2: 0x88B5,
7250     0xE5D3: 0x8872,
7251     0xE5D4: 0x8882,
7252     0xE5D5: 0x8897,
7253     0xE5D6: 0x8892,
7254     0xE5D7: 0x88AE,
7255     0xE5D8: 0x8899,
7256     0xE5D9: 0x88A2,
7257     0xE5DA: 0x888D,
7258     0xE5DB: 0x88A4,
7259     0xE5DC: 0x88B0,
7260     0xE5DD: 0x88BF,
7261     0xE5DE: 0x88B1,
7262     0xE5DF: 0x88C3,
7263     0xE5E0: 0x88C4,
7264     0xE5E1: 0x88D4,
7265     0xE5E2: 0x88D8,
7266     0xE5E3: 0x88D9,
7267     0xE5E4: 0x88DD,
7268     0xE5E5: 0x88F9,
7269     0xE5E6: 0x8902,
7270     0xE5E7: 0x88FC,
7271     0xE5E8: 0x88F4,
7272     0xE5E9: 0x88E8,
7273     0xE5EA: 0x88F2,
7274     0xE5EB: 0x8904,
7275     0xE5EC: 0x890C,
7276     0xE5ED: 0x890A,
7277     0xE5EE: 0x8913,
7278     0xE5EF: 0x8943,
7279     0xE5F0: 0x891E,
7280     0xE5F1: 0x8925,
7281     0xE5F2: 0x892A,
7282     0xE5F3: 0x892B,
7283     0xE5F4: 0x8941,
7284     0xE5F5: 0x8944,
7285     0xE5F6: 0x893B,
7286     0xE5F7: 0x8936,
7287     0xE5F8: 0x8938,
7288     0xE5F9: 0x894C,
7289     0xE5FA: 0x891D,
7290     0xE5FB: 0x8960,
7291     0xE5FC: 0x895E,
7292     0xE640: 0x8966,
7293     0xE641: 0x8964,
7294     0xE642: 0x896D,
7295     0xE643: 0x896A,
7296     0xE644: 0x896F,
7297     0xE645: 0x8974,
7298     0xE646: 0x8977,
7299     0xE647: 0x897E,
7300     0xE648: 0x8983,
7301     0xE649: 0x8988,
7302     0xE64A: 0x898A,
7303     0xE64B: 0x8993,
7304     0xE64C: 0x8998,
7305     0xE64D: 0x89A1,
7306     0xE64E: 0x89A9,
7307     0xE64F: 0x89A6,
7308     0xE650: 0x89AC,
7309     0xE651: 0x89AF,
7310     0xE652: 0x89B2,
7311     0xE653: 0x89BA,
7312     0xE654: 0x89BD,
7313     0xE655: 0x89BF,
7314     0xE656: 0x89C0,
7315     0xE657: 0x89DA,
7316     0xE658: 0x89DC,
7317     0xE659: 0x89DD,
7318     0xE65A: 0x89E7,
7319     0xE65B: 0x89F4,
7320     0xE65C: 0x89F8,
7321     0xE65D: 0x8A03,
7322     0xE65E: 0x8A16,
7323     0xE65F: 0x8A10,
7324     0xE660: 0x8A0C,
7325     0xE661: 0x8A1B,
7326     0xE662: 0x8A1D,
7327     0xE663: 0x8A25,
7328     0xE664: 0x8A36,
7329     0xE665: 0x8A41,
7330     0xE666: 0x8A5B,
7331     0xE667: 0x8A52,
7332     0xE668: 0x8A46,
7333     0xE669: 0x8A48,
7334     0xE66A: 0x8A7C,
7335     0xE66B: 0x8A6D,
7336     0xE66C: 0x8A6C,
7337     0xE66D: 0x8A62,
7338     0xE66E: 0x8A85,
7339     0xE66F: 0x8A82,
7340     0xE670: 0x8A84,
7341     0xE671: 0x8AA8,
7342     0xE672: 0x8AA1,
7343     0xE673: 0x8A91,
7344     0xE674: 0x8AA5,
7345     0xE675: 0x8AA6,
7346     0xE676: 0x8A9A,
7347     0xE677: 0x8AA3,
7348     0xE678: 0x8AC4,
7349     0xE679: 0x8ACD,
7350     0xE67A: 0x8AC2,
7351     0xE67B: 0x8ADA,
7352     0xE67C: 0x8AEB,
7353     0xE67D: 0x8AF3,
7354     0xE67E: 0x8AE7,
7355     0xE680: 0x8AE4,
7356     0xE681: 0x8AF1,
7357     0xE682: 0x8B14,
7358     0xE683: 0x8AE0,
7359     0xE684: 0x8AE2,
7360     0xE685: 0x8AF7,
7361     0xE686: 0x8ADE,
7362     0xE687: 0x8ADB,
7363     0xE688: 0x8B0C,
7364     0xE689: 0x8B07,
7365     0xE68A: 0x8B1A,
7366     0xE68B: 0x8AE1,
7367     0xE68C: 0x8B16,
7368     0xE68D: 0x8B10,
7369     0xE68E: 0x8B17,
7370     0xE68F: 0x8B20,
7371     0xE690: 0x8B33,
7372     0xE691: 0x97AB,
7373     0xE692: 0x8B26,
7374     0xE693: 0x8B2B,
7375     0xE694: 0x8B3E,
7376     0xE695: 0x8B28,
7377     0xE696: 0x8B41,
7378     0xE697: 0x8B4C,
7379     0xE698: 0x8B4F,
7380     0xE699: 0x8B4E,
7381     0xE69A: 0x8B49,
7382     0xE69B: 0x8B56,
7383     0xE69C: 0x8B5B,
7384     0xE69D: 0x8B5A,
7385     0xE69E: 0x8B6B,
7386     0xE69F: 0x8B5F,
7387     0xE6A0: 0x8B6C,
7388     0xE6A1: 0x8B6F,
7389     0xE6A2: 0x8B74,
7390     0xE6A3: 0x8B7D,
7391     0xE6A4: 0x8B80,
7392     0xE6A5: 0x8B8C,
7393     0xE6A6: 0x8B8E,
7394     0xE6A7: 0x8B92,
7395     0xE6A8: 0x8B93,
7396     0xE6A9: 0x8B96,
7397     0xE6AA: 0x8B99,
7398     0xE6AB: 0x8B9A,
7399     0xE6AC: 0x8C3A,
7400     0xE6AD: 0x8C41,
7401     0xE6AE: 0x8C3F,
7402     0xE6AF: 0x8C48,
7403     0xE6B0: 0x8C4C,
7404     0xE6B1: 0x8C4E,
7405     0xE6B2: 0x8C50,
7406     0xE6B3: 0x8C55,
7407     0xE6B4: 0x8C62,
7408     0xE6B5: 0x8C6C,
7409     0xE6B6: 0x8C78,
7410     0xE6B7: 0x8C7A,
7411     0xE6B8: 0x8C82,
7412     0xE6B9: 0x8C89,
7413     0xE6BA: 0x8C85,
7414     0xE6BB: 0x8C8A,
7415     0xE6BC: 0x8C8D,
7416     0xE6BD: 0x8C8E,
7417     0xE6BE: 0x8C94,
7418     0xE6BF: 0x8C7C,
7419     0xE6C0: 0x8C98,
7420     0xE6C1: 0x621D,
7421     0xE6C2: 0x8CAD,
7422     0xE6C3: 0x8CAA,
7423     0xE6C4: 0x8CBD,
7424     0xE6C5: 0x8CB2,
7425     0xE6C6: 0x8CB3,
7426     0xE6C7: 0x8CAE,
7427     0xE6C8: 0x8CB6,
7428     0xE6C9: 0x8CC8,
7429     0xE6CA: 0x8CC1,
7430     0xE6CB: 0x8CE4,
7431     0xE6CC: 0x8CE3,
7432     0xE6CD: 0x8CDA,
7433     0xE6CE: 0x8CFD,
7434     0xE6CF: 0x8CFA,
7435     0xE6D0: 0x8CFB,
7436     0xE6D1: 0x8D04,
7437     0xE6D2: 0x8D05,
7438     0xE6D3: 0x8D0A,
7439     0xE6D4: 0x8D07,
7440     0xE6D5: 0x8D0F,
7441     0xE6D6: 0x8D0D,
7442     0xE6D7: 0x8D10,
7443     0xE6D8: 0x9F4E,
7444     0xE6D9: 0x8D13,
7445     0xE6DA: 0x8CCD,
7446     0xE6DB: 0x8D14,
7447     0xE6DC: 0x8D16,
7448     0xE6DD: 0x8D67,
7449     0xE6DE: 0x8D6D,
7450     0xE6DF: 0x8D71,
7451     0xE6E0: 0x8D73,
7452     0xE6E1: 0x8D81,
7453     0xE6E2: 0x8D99,
7454     0xE6E3: 0x8DC2,
7455     0xE6E4: 0x8DBE,
7456     0xE6E5: 0x8DBA,
7457     0xE6E6: 0x8DCF,
7458     0xE6E7: 0x8DDA,
7459     0xE6E8: 0x8DD6,
7460     0xE6E9: 0x8DCC,
7461     0xE6EA: 0x8DDB,
7462     0xE6EB: 0x8DCB,
7463     0xE6EC: 0x8DEA,
7464     0xE6ED: 0x8DEB,
7465     0xE6EE: 0x8DDF,
7466     0xE6EF: 0x8DE3,
7467     0xE6F0: 0x8DFC,
7468     0xE6F1: 0x8E08,
7469     0xE6F2: 0x8E09,
7470     0xE6F3: 0x8DFF,
7471     0xE6F4: 0x8E1D,
7472     0xE6F5: 0x8E1E,
7473     0xE6F6: 0x8E10,
7474     0xE6F7: 0x8E1F,
7475     0xE6F8: 0x8E42,
7476     0xE6F9: 0x8E35,
7477     0xE6FA: 0x8E30,
7478     0xE6FB: 0x8E34,
7479     0xE6FC: 0x8E4A,
7480     0xE740: 0x8E47,
7481     0xE741: 0x8E49,
7482     0xE742: 0x8E4C,
7483     0xE743: 0x8E50,
7484     0xE744: 0x8E48,
7485     0xE745: 0x8E59,
7486     0xE746: 0x8E64,
7487     0xE747: 0x8E60,
7488     0xE748: 0x8E2A,
7489     0xE749: 0x8E63,
7490     0xE74A: 0x8E55,
7491     0xE74B: 0x8E76,
7492     0xE74C: 0x8E72,
7493     0xE74D: 0x8E7C,
7494     0xE74E: 0x8E81,
7495     0xE74F: 0x8E87,
7496     0xE750: 0x8E85,
7497     0xE751: 0x8E84,
7498     0xE752: 0x8E8B,
7499     0xE753: 0x8E8A,
7500     0xE754: 0x8E93,
7501     0xE755: 0x8E91,
7502     0xE756: 0x8E94,
7503     0xE757: 0x8E99,
7504     0xE758: 0x8EAA,
7505     0xE759: 0x8EA1,
7506     0xE75A: 0x8EAC,
7507     0xE75B: 0x8EB0,
7508     0xE75C: 0x8EC6,
7509     0xE75D: 0x8EB1,
7510     0xE75E: 0x8EBE,
7511     0xE75F: 0x8EC5,
7512     0xE760: 0x8EC8,
7513     0xE761: 0x8ECB,
7514     0xE762: 0x8EDB,
7515     0xE763: 0x8EE3,
7516     0xE764: 0x8EFC,
7517     0xE765: 0x8EFB,
7518     0xE766: 0x8EEB,
7519     0xE767: 0x8EFE,
7520     0xE768: 0x8F0A,
7521     0xE769: 0x8F05,
7522     0xE76A: 0x8F15,
7523     0xE76B: 0x8F12,
7524     0xE76C: 0x8F19,
7525     0xE76D: 0x8F13,
7526     0xE76E: 0x8F1C,
7527     0xE76F: 0x8F1F,
7528     0xE770: 0x8F1B,
7529     0xE771: 0x8F0C,
7530     0xE772: 0x8F26,
7531     0xE773: 0x8F33,
7532     0xE774: 0x8F3B,
7533     0xE775: 0x8F39,
7534     0xE776: 0x8F45,
7535     0xE777: 0x8F42,
7536     0xE778: 0x8F3E,
7537     0xE779: 0x8F4C,
7538     0xE77A: 0x8F49,
7539     0xE77B: 0x8F46,
7540     0xE77C: 0x8F4E,
7541     0xE77D: 0x8F57,
7542     0xE77E: 0x8F5C,
7543     0xE780: 0x8F62,
7544     0xE781: 0x8F63,
7545     0xE782: 0x8F64,
7546     0xE783: 0x8F9C,
7547     0xE784: 0x8F9F,
7548     0xE785: 0x8FA3,
7549     0xE786: 0x8FAD,
7550     0xE787: 0x8FAF,
7551     0xE788: 0x8FB7,
7552     0xE789: 0x8FDA,
7553     0xE78A: 0x8FE5,
7554     0xE78B: 0x8FE2,
7555     0xE78C: 0x8FEA,
7556     0xE78D: 0x8FEF,
7557     0xE78E: 0x9087,
7558     0xE78F: 0x8FF4,
7559     0xE790: 0x9005,
7560     0xE791: 0x8FF9,
7561     0xE792: 0x8FFA,
7562     0xE793: 0x9011,
7563     0xE794: 0x9015,
7564     0xE795: 0x9021,
7565     0xE796: 0x900D,
7566     0xE797: 0x901E,
7567     0xE798: 0x9016,
7568     0xE799: 0x900B,
7569     0xE79A: 0x9027,
7570     0xE79B: 0x9036,
7571     0xE79C: 0x9035,
7572     0xE79D: 0x9039,
7573     0xE79E: 0x8FF8,
7574     0xE79F: 0x904F,
7575     0xE7A0: 0x9050,
7576     0xE7A1: 0x9051,
7577     0xE7A2: 0x9052,
7578     0xE7A3: 0x900E,
7579     0xE7A4: 0x9049,
7580     0xE7A5: 0x903E,
7581     0xE7A6: 0x9056,
7582     0xE7A7: 0x9058,
7583     0xE7A8: 0x905E,
7584     0xE7A9: 0x9068,
7585     0xE7AA: 0x906F,
7586     0xE7AB: 0x9076,
7587     0xE7AC: 0x96A8,
7588     0xE7AD: 0x9072,
7589     0xE7AE: 0x9082,
7590     0xE7AF: 0x907D,
7591     0xE7B0: 0x9081,
7592     0xE7B1: 0x9080,
7593     0xE7B2: 0x908A,
7594     0xE7B3: 0x9089,
7595     0xE7B4: 0x908F,
7596     0xE7B5: 0x90A8,
7597     0xE7B6: 0x90AF,
7598     0xE7B7: 0x90B1,
7599     0xE7B8: 0x90B5,
7600     0xE7B9: 0x90E2,
7601     0xE7BA: 0x90E4,
7602     0xE7BB: 0x6248,
7603     0xE7BC: 0x90DB,
7604     0xE7BD: 0x9102,
7605     0xE7BE: 0x9112,
7606     0xE7BF: 0x9119,
7607     0xE7C0: 0x9132,
7608     0xE7C1: 0x9130,
7609     0xE7C2: 0x914A,
7610     0xE7C3: 0x9156,
7611     0xE7C4: 0x9158,
7612     0xE7C5: 0x9163,
7613     0xE7C6: 0x9165,
7614     0xE7C7: 0x9169,
7615     0xE7C8: 0x9173,
7616     0xE7C9: 0x9172,
7617     0xE7CA: 0x918B,
7618     0xE7CB: 0x9189,
7619     0xE7CC: 0x9182,
7620     0xE7CD: 0x91A2,
7621     0xE7CE: 0x91AB,
7622     0xE7CF: 0x91AF,
7623     0xE7D0: 0x91AA,
7624     0xE7D1: 0x91B5,
7625     0xE7D2: 0x91B4,
7626     0xE7D3: 0x91BA,
7627     0xE7D4: 0x91C0,
7628     0xE7D5: 0x91C1,
7629     0xE7D6: 0x91C9,
7630     0xE7D7: 0x91CB,
7631     0xE7D8: 0x91D0,
7632     0xE7D9: 0x91D6,
7633     0xE7DA: 0x91DF,
7634     0xE7DB: 0x91E1,
7635     0xE7DC: 0x91DB,
7636     0xE7DD: 0x91FC,
7637     0xE7DE: 0x91F5,
7638     0xE7DF: 0x91F6,
7639     0xE7E0: 0x921E,
7640     0xE7E1: 0x91FF,
7641     0xE7E2: 0x9214,
7642     0xE7E3: 0x922C,
7643     0xE7E4: 0x9215,
7644     0xE7E5: 0x9211,
7645     0xE7E6: 0x925E,
7646     0xE7E7: 0x9257,
7647     0xE7E8: 0x9245,
7648     0xE7E9: 0x9249,
7649     0xE7EA: 0x9264,
7650     0xE7EB: 0x9248,
7651     0xE7EC: 0x9295,
7652     0xE7ED: 0x923F,
7653     0xE7EE: 0x924B,
7654     0xE7EF: 0x9250,
7655     0xE7F0: 0x929C,
7656     0xE7F1: 0x9296,
7657     0xE7F2: 0x9293,
7658     0xE7F3: 0x929B,
7659     0xE7F4: 0x925A,
7660     0xE7F5: 0x92CF,
7661     0xE7F6: 0x92B9,
7662     0xE7F7: 0x92B7,
7663     0xE7F8: 0x92E9,
7664     0xE7F9: 0x930F,
7665     0xE7FA: 0x92FA,
7666     0xE7FB: 0x9344,
7667     0xE7FC: 0x932E,
7668     0xE840: 0x9319,
7669     0xE841: 0x9322,
7670     0xE842: 0x931A,
7671     0xE843: 0x9323,
7672     0xE844: 0x933A,
7673     0xE845: 0x9335,
7674     0xE846: 0x933B,
7675     0xE847: 0x935C,
7676     0xE848: 0x9360,
7677     0xE849: 0x937C,
7678     0xE84A: 0x936E,
7679     0xE84B: 0x9356,
7680     0xE84C: 0x93B0,
7681     0xE84D: 0x93AC,
7682     0xE84E: 0x93AD,
7683     0xE84F: 0x9394,
7684     0xE850: 0x93B9,
7685     0xE851: 0x93D6,
7686     0xE852: 0x93D7,
7687     0xE853: 0x93E8,
7688     0xE854: 0x93E5,
7689     0xE855: 0x93D8,
7690     0xE856: 0x93C3,
7691     0xE857: 0x93DD,
7692     0xE858: 0x93D0,
7693     0xE859: 0x93C8,
7694     0xE85A: 0x93E4,
7695     0xE85B: 0x941A,
7696     0xE85C: 0x9414,
7697     0xE85D: 0x9413,
7698     0xE85E: 0x9403,
7699     0xE85F: 0x9407,
7700     0xE860: 0x9410,
7701     0xE861: 0x9436,
7702     0xE862: 0x942B,
7703     0xE863: 0x9435,
7704     0xE864: 0x9421,
7705     0xE865: 0x943A,
7706     0xE866: 0x9441,
7707     0xE867: 0x9452,
7708     0xE868: 0x9444,
7709     0xE869: 0x945B,
7710     0xE86A: 0x9460,
7711     0xE86B: 0x9462,
7712     0xE86C: 0x945E,
7713     0xE86D: 0x946A,
7714     0xE86E: 0x9229,
7715     0xE86F: 0x9470,
7716     0xE870: 0x9475,
7717     0xE871: 0x9477,
7718     0xE872: 0x947D,
7719     0xE873: 0x945A,
7720     0xE874: 0x947C,
7721     0xE875: 0x947E,
7722     0xE876: 0x9481,
7723     0xE877: 0x947F,
7724     0xE878: 0x9582,
7725     0xE879: 0x9587,
7726     0xE87A: 0x958A,
7727     0xE87B: 0x9594,
7728     0xE87C: 0x9596,
7729     0xE87D: 0x9598,
7730     0xE87E: 0x9599,
7731     0xE880: 0x95A0,
7732     0xE881: 0x95A8,
7733     0xE882: 0x95A7,
7734     0xE883: 0x95AD,
7735     0xE884: 0x95BC,
7736     0xE885: 0x95BB,
7737     0xE886: 0x95B9,
7738     0xE887: 0x95BE,
7739     0xE888: 0x95CA,
7740     0xE889: 0x6FF6,
7741     0xE88A: 0x95C3,
7742     0xE88B: 0x95CD,
7743     0xE88C: 0x95CC,
7744     0xE88D: 0x95D5,
7745     0xE88E: 0x95D4,
7746     0xE88F: 0x95D6,
7747     0xE890: 0x95DC,
7748     0xE891: 0x95E1,
7749     0xE892: 0x95E5,
7750     0xE893: 0x95E2,
7751     0xE894: 0x9621,
7752     0xE895: 0x9628,
7753     0xE896: 0x962E,
7754     0xE897: 0x962F,
7755     0xE898: 0x9642,
7756     0xE899: 0x964C,
7757     0xE89A: 0x964F,
7758     0xE89B: 0x964B,
7759     0xE89C: 0x9677,
7760     0xE89D: 0x965C,
7761     0xE89E: 0x965E,
7762     0xE89F: 0x965D,
7763     0xE8A0: 0x965F,
7764     0xE8A1: 0x9666,
7765     0xE8A2: 0x9672,
7766     0xE8A3: 0x966C,
7767     0xE8A4: 0x968D,
7768     0xE8A5: 0x9698,
7769     0xE8A6: 0x9695,
7770     0xE8A7: 0x9697,
7771     0xE8A8: 0x96AA,
7772     0xE8A9: 0x96A7,
7773     0xE8AA: 0x96B1,
7774     0xE8AB: 0x96B2,
7775     0xE8AC: 0x96B0,
7776     0xE8AD: 0x96B4,
7777     0xE8AE: 0x96B6,
7778     0xE8AF: 0x96B8,
7779     0xE8B0: 0x96B9,
7780     0xE8B1: 0x96CE,
7781     0xE8B2: 0x96CB,
7782     0xE8B3: 0x96C9,
7783     0xE8B4: 0x96CD,
7784     0xE8B5: 0x894D,
7785     0xE8B6: 0x96DC,
7786     0xE8B7: 0x970D,
7787     0xE8B8: 0x96D5,
7788     0xE8B9: 0x96F9,
7789     0xE8BA: 0x9704,
7790     0xE8BB: 0x9706,
7791     0xE8BC: 0x9708,
7792     0xE8BD: 0x9713,
7793     0xE8BE: 0x970E,
7794     0xE8BF: 0x9711,
7795     0xE8C0: 0x970F,
7796     0xE8C1: 0x9716,
7797     0xE8C2: 0x9719,
7798     0xE8C3: 0x9724,
7799     0xE8C4: 0x972A,
7800     0xE8C5: 0x9730,
7801     0xE8C6: 0x9739,
7802     0xE8C7: 0x973D,
7803     0xE8C8: 0x973E,
7804     0xE8C9: 0x9744,
7805     0xE8CA: 0x9746,
7806     0xE8CB: 0x9748,
7807     0xE8CC: 0x9742,
7808     0xE8CD: 0x9749,
7809     0xE8CE: 0x975C,
7810     0xE8CF: 0x9760,
7811     0xE8D0: 0x9764,
7812     0xE8D1: 0x9766,
7813     0xE8D2: 0x9768,
7814     0xE8D3: 0x52D2,
7815     0xE8D4: 0x976B,
7816     0xE8D5: 0x9771,
7817     0xE8D6: 0x9779,
7818     0xE8D7: 0x9785,
7819     0xE8D8: 0x977C,
7820     0xE8D9: 0x9781,
7821     0xE8DA: 0x977A,
7822     0xE8DB: 0x9786,
7823     0xE8DC: 0x978B,
7824     0xE8DD: 0x978F,
7825     0xE8DE: 0x9790,
7826     0xE8DF: 0x979C,
7827     0xE8E0: 0x97A8,
7828     0xE8E1: 0x97A6,
7829     0xE8E2: 0x97A3,
7830     0xE8E3: 0x97B3,
7831     0xE8E4: 0x97B4,
7832     0xE8E5: 0x97C3,
7833     0xE8E6: 0x97C6,
7834     0xE8E7: 0x97C8,
7835     0xE8E8: 0x97CB,
7836     0xE8E9: 0x97DC,
7837     0xE8EA: 0x97ED,
7838     0xE8EB: 0x9F4F,
7839     0xE8EC: 0x97F2,
7840     0xE8ED: 0x7ADF,
7841     0xE8EE: 0x97F6,
7842     0xE8EF: 0x97F5,
7843     0xE8F0: 0x980F,
7844     0xE8F1: 0x980C,
7845     0xE8F2: 0x9838,
7846     0xE8F3: 0x9824,
7847     0xE8F4: 0x9821,
7848     0xE8F5: 0x9837,
7849     0xE8F6: 0x983D,
7850     0xE8F7: 0x9846,
7851     0xE8F8: 0x984F,
7852     0xE8F9: 0x984B,
7853     0xE8FA: 0x986B,
7854     0xE8FB: 0x986F,
7855     0xE8FC: 0x9870,
7856     0xE940: 0x9871,
7857     0xE941: 0x9874,
7858     0xE942: 0x9873,
7859     0xE943: 0x98AA,
7860     0xE944: 0x98AF,
7861     0xE945: 0x98B1,
7862     0xE946: 0x98B6,
7863     0xE947: 0x98C4,
7864     0xE948: 0x98C3,
7865     0xE949: 0x98C6,
7866     0xE94A: 0x98E9,
7867     0xE94B: 0x98EB,
7868     0xE94C: 0x9903,
7869     0xE94D: 0x9909,
7870     0xE94E: 0x9912,
7871     0xE94F: 0x9914,
7872     0xE950: 0x9918,
7873     0xE951: 0x9921,
7874     0xE952: 0x991D,
7875     0xE953: 0x991E,
7876     0xE954: 0x9924,
7877     0xE955: 0x9920,
7878     0xE956: 0x992C,
7879     0xE957: 0x992E,
7880     0xE958: 0x993D,
7881     0xE959: 0x993E,
7882     0xE95A: 0x9942,
7883     0xE95B: 0x9949,
7884     0xE95C: 0x9945,
7885     0xE95D: 0x9950,
7886     0xE95E: 0x994B,
7887     0xE95F: 0x9951,
7888     0xE960: 0x9952,
7889     0xE961: 0x994C,
7890     0xE962: 0x9955,
7891     0xE963: 0x9997,
7892     0xE964: 0x9998,
7893     0xE965: 0x99A5,
7894     0xE966: 0x99AD,
7895     0xE967: 0x99AE,
7896     0xE968: 0x99BC,
7897     0xE969: 0x99DF,
7898     0xE96A: 0x99DB,
7899     0xE96B: 0x99DD,
7900     0xE96C: 0x99D8,
7901     0xE96D: 0x99D1,
7902     0xE96E: 0x99ED,
7903     0xE96F: 0x99EE,
7904     0xE970: 0x99F1,
7905     0xE971: 0x99F2,
7906     0xE972: 0x99FB,
7907     0xE973: 0x99F8,
7908     0xE974: 0x9A01,
7909     0xE975: 0x9A0F,
7910     0xE976: 0x9A05,
7911     0xE977: 0x99E2,
7912     0xE978: 0x9A19,
7913     0xE979: 0x9A2B,
7914     0xE97A: 0x9A37,
7915     0xE97B: 0x9A45,
7916     0xE97C: 0x9A42,
7917     0xE97D: 0x9A40,
7918     0xE97E: 0x9A43,
7919     0xE980: 0x9A3E,
7920     0xE981: 0x9A55,
7921     0xE982: 0x9A4D,
7922     0xE983: 0x9A5B,
7923     0xE984: 0x9A57,
7924     0xE985: 0x9A5F,
7925     0xE986: 0x9A62,
7926     0xE987: 0x9A65,
7927     0xE988: 0x9A64,
7928     0xE989: 0x9A69,
7929     0xE98A: 0x9A6B,
7930     0xE98B: 0x9A6A,
7931     0xE98C: 0x9AAD,
7932     0xE98D: 0x9AB0,
7933     0xE98E: 0x9ABC,
7934     0xE98F: 0x9AC0,
7935     0xE990: 0x9ACF,
7936     0xE991: 0x9AD1,
7937     0xE992: 0x9AD3,
7938     0xE993: 0x9AD4,
7939     0xE994: 0x9ADE,
7940     0xE995: 0x9ADF,
7941     0xE996: 0x9AE2,
7942     0xE997: 0x9AE3,
7943     0xE998: 0x9AE6,
7944     0xE999: 0x9AEF,
7945     0xE99A: 0x9AEB,
7946     0xE99B: 0x9AEE,
7947     0xE99C: 0x9AF4,
7948     0xE99D: 0x9AF1,
7949     0xE99E: 0x9AF7,
7950     0xE99F: 0x9AFB,
7951     0xE9A0: 0x9B06,
7952     0xE9A1: 0x9B18,
7953     0xE9A2: 0x9B1A,
7954     0xE9A3: 0x9B1F,
7955     0xE9A4: 0x9B22,
7956     0xE9A5: 0x9B23,
7957     0xE9A6: 0x9B25,
7958     0xE9A7: 0x9B27,
7959     0xE9A8: 0x9B28,
7960     0xE9A9: 0x9B29,
7961     0xE9AA: 0x9B2A,
7962     0xE9AB: 0x9B2E,
7963     0xE9AC: 0x9B2F,
7964     0xE9AD: 0x9B32,
7965     0xE9AE: 0x9B44,
7966     0xE9AF: 0x9B43,
7967     0xE9B0: 0x9B4F,
7968     0xE9B1: 0x9B4D,
7969     0xE9B2: 0x9B4E,
7970     0xE9B3: 0x9B51,
7971     0xE9B4: 0x9B58,
7972     0xE9B5: 0x9B74,
7973     0xE9B6: 0x9B93,
7974     0xE9B7: 0x9B83,
7975     0xE9B8: 0x9B91,
7976     0xE9B9: 0x9B96,
7977     0xE9BA: 0x9B97,
7978     0xE9BB: 0x9B9F,
7979     0xE9BC: 0x9BA0,
7980     0xE9BD: 0x9BA8,
7981     0xE9BE: 0x9BB4,
7982     0xE9BF: 0x9BC0,
7983     0xE9C0: 0x9BCA,
7984     0xE9C1: 0x9BB9,
7985     0xE9C2: 0x9BC6,
7986     0xE9C3: 0x9BCF,
7987     0xE9C4: 0x9BD1,
7988     0xE9C5: 0x9BD2,
7989     0xE9C6: 0x9BE3,
7990     0xE9C7: 0x9BE2,
7991     0xE9C8: 0x9BE4,
7992     0xE9C9: 0x9BD4,
7993     0xE9CA: 0x9BE1,
7994     0xE9CB: 0x9C3A,
7995     0xE9CC: 0x9BF2,
7996     0xE9CD: 0x9BF1,
7997     0xE9CE: 0x9BF0,
7998     0xE9CF: 0x9C15,
7999     0xE9D0: 0x9C14,
8000     0xE9D1: 0x9C09,
8001     0xE9D2: 0x9C13,
8002     0xE9D3: 0x9C0C,
8003     0xE9D4: 0x9C06,
8004     0xE9D5: 0x9C08,
8005     0xE9D6: 0x9C12,
8006     0xE9D7: 0x9C0A,
8007     0xE9D8: 0x9C04,
8008     0xE9D9: 0x9C2E,
8009     0xE9DA: 0x9C1B,
8010     0xE9DB: 0x9C25,
8011     0xE9DC: 0x9C24,
8012     0xE9DD: 0x9C21,
8013     0xE9DE: 0x9C30,
8014     0xE9DF: 0x9C47,
8015     0xE9E0: 0x9C32,
8016     0xE9E1: 0x9C46,
8017     0xE9E2: 0x9C3E,
8018     0xE9E3: 0x9C5A,
8019     0xE9E4: 0x9C60,
8020     0xE9E5: 0x9C67,
8021     0xE9E6: 0x9C76,
8022     0xE9E7: 0x9C78,
8023     0xE9E8: 0x9CE7,
8024     0xE9E9: 0x9CEC,
8025     0xE9EA: 0x9CF0,
8026     0xE9EB: 0x9D09,
8027     0xE9EC: 0x9D08,
8028     0xE9ED: 0x9CEB,
8029     0xE9EE: 0x9D03,
8030     0xE9EF: 0x9D06,
8031     0xE9F0: 0x9D2A,
8032     0xE9F1: 0x9D26,
8033     0xE9F2: 0x9DAF,
8034     0xE9F3: 0x9D23,
8035     0xE9F4: 0x9D1F,
8036     0xE9F5: 0x9D44,
8037     0xE9F6: 0x9D15,
8038     0xE9F7: 0x9D12,
8039     0xE9F8: 0x9D41,
8040     0xE9F9: 0x9D3F,
8041     0xE9FA: 0x9D3E,
8042     0xE9FB: 0x9D46,
8043     0xE9FC: 0x9D48,
8044     0xEA40: 0x9D5D,
8045     0xEA41: 0x9D5E,
8046     0xEA42: 0x9D64,
8047     0xEA43: 0x9D51,
8048     0xEA44: 0x9D50,
8049     0xEA45: 0x9D59,
8050     0xEA46: 0x9D72,
8051     0xEA47: 0x9D89,
8052     0xEA48: 0x9D87,
8053     0xEA49: 0x9DAB,
8054     0xEA4A: 0x9D6F,
8055     0xEA4B: 0x9D7A,
8056     0xEA4C: 0x9D9A,
8057     0xEA4D: 0x9DA4,
8058     0xEA4E: 0x9DA9,
8059     0xEA4F: 0x9DB2,
8060     0xEA50: 0x9DC4,
8061     0xEA51: 0x9DC1,
8062     0xEA52: 0x9DBB,
8063     0xEA53: 0x9DB8,
8064     0xEA54: 0x9DBA,
8065     0xEA55: 0x9DC6,
8066     0xEA56: 0x9DCF,
8067     0xEA57: 0x9DC2,
8068     0xEA58: 0x9DD9,
8069     0xEA59: 0x9DD3,
8070     0xEA5A: 0x9DF8,
8071     0xEA5B: 0x9DE6,
8072     0xEA5C: 0x9DED,
8073     0xEA5D: 0x9DEF,
8074     0xEA5E: 0x9DFD,
8075     0xEA5F: 0x9E1A,
8076     0xEA60: 0x9E1B,
8077     0xEA61: 0x9E1E,
8078     0xEA62: 0x9E75,
8079     0xEA63: 0x9E79,
8080     0xEA64: 0x9E7D,
8081     0xEA65: 0x9E81,
8082     0xEA66: 0x9E88,
8083     0xEA67: 0x9E8B,
8084     0xEA68: 0x9E8C,
8085     0xEA69: 0x9E92,
8086     0xEA6A: 0x9E95,
8087     0xEA6B: 0x9E91,
8088     0xEA6C: 0x9E9D,
8089     0xEA6D: 0x9EA5,
8090     0xEA6E: 0x9EA9,
8091     0xEA6F: 0x9EB8,
8092     0xEA70: 0x9EAA,
8093     0xEA71: 0x9EAD,
8094     0xEA72: 0x9761,
8095     0xEA73: 0x9ECC,
8096     0xEA74: 0x9ECE,
8097     0xEA75: 0x9ECF,
8098     0xEA76: 0x9ED0,
8099     0xEA77: 0x9ED4,
8100     0xEA78: 0x9EDC,
8101     0xEA79: 0x9EDE,
8102     0xEA7A: 0x9EDD,
8103     0xEA7B: 0x9EE0,
8104     0xEA7C: 0x9EE5,
8105     0xEA7D: 0x9EE8,
8106     0xEA7E: 0x9EEF,
8107     0xEA80: 0x9EF4,
8108     0xEA81: 0x9EF6,
8109     0xEA82: 0x9EF7,
8110     0xEA83: 0x9EF9,
8111     0xEA84: 0x9EFB,
8112     0xEA85: 0x9EFC,
8113     0xEA86: 0x9EFD,
8114     0xEA87: 0x9F07,
8115     0xEA88: 0x9F08,
8116     0xEA89: 0x76B7,
8117     0xEA8A: 0x9F15,
8118     0xEA8B: 0x9F21,
8119     0xEA8C: 0x9F2C,
8120     0xEA8D: 0x9F3E,
8121     0xEA8E: 0x9F4A,
8122     0xEA8F: 0x9F52,
8123     0xEA90: 0x9F54,
8124     0xEA91: 0x9F63,
8125     0xEA92: 0x9F5F,
8126     0xEA93: 0x9F60,
8127     0xEA94: 0x9F61,
8128     0xEA95: 0x9F66,
8129     0xEA96: 0x9F67,
8130     0xEA97: 0x9F6C,
8131     0xEA98: 0x9F6A,
8132     0xEA99: 0x9F77,
8133     0xEA9A: 0x9F72,
8134     0xEA9B: 0x9F76,
8135     0xEA9C: 0x9F95,
8136     0xEA9D: 0x9F9C,
8137     0xEA9E: 0x9FA0,
8138     0xEA9F: 0x582F,
8139     0xEAA0: 0x69C7,
8140     0xEAA1: 0x9059,
8141     0xEAA2: 0x7464,
8142     0xEAA3: 0x51DC,
8143     0xEAA4: 0x7199,
8144 };
8145
8146
8147 /***/ }),
8148 /* 9 */
8149 /***/ (function(module, exports, __webpack_require__) {
8150
8151 "use strict";
8152
8153 Object.defineProperty(exports, "__esModule", { value: true });
8154 var GenericGF_1 = __webpack_require__(1);
8155 var GenericGFPoly_1 = __webpack_require__(2);
8156 function runEuclideanAlgorithm(field, a, b, R) {
8157     var _a;
8158     // Assume a's degree is >= b's
8159     if (a.degree() < b.degree()) {
8160         _a = [b, a], a = _a[0], b = _a[1];
8161     }
8162     var rLast = a;
8163     var r = b;
8164     var tLast = field.zero;
8165     var t = field.one;
8166     // Run Euclidean algorithm until r's degree is less than R/2
8167     while (r.degree() >= R / 2) {
8168         var rLastLast = rLast;
8169         var tLastLast = tLast;
8170         rLast = r;
8171         tLast = t;
8172         // Divide rLastLast by rLast, with quotient in q and remainder in r
8173         if (rLast.isZero()) {
8174             // Euclidean algorithm already terminated?
8175             return null;
8176         }
8177         r = rLastLast;
8178         var q = field.zero;
8179         var denominatorLeadingTerm = rLast.getCoefficient(rLast.degree());
8180         var dltInverse = field.inverse(denominatorLeadingTerm);
8181         while (r.degree() >= rLast.degree() && !r.isZero()) {
8182             var degreeDiff = r.degree() - rLast.degree();
8183             var scale = field.multiply(r.getCoefficient(r.degree()), dltInverse);
8184             q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));
8185             r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));
8186         }
8187         t = q.multiplyPoly(tLast).addOrSubtract(tLastLast);
8188         if (r.degree() >= rLast.degree()) {
8189             return null;
8190         }
8191     }
8192     var sigmaTildeAtZero = t.getCoefficient(0);
8193     if (sigmaTildeAtZero === 0) {
8194         return null;
8195     }
8196     var inverse = field.inverse(sigmaTildeAtZero);
8197     return [t.multiply(inverse), r.multiply(inverse)];
8198 }
8199 function findErrorLocations(field, errorLocator) {
8200     // This is a direct application of Chien's search
8201     var numErrors = errorLocator.degree();
8202     if (numErrors === 1) {
8203         return [errorLocator.getCoefficient(1)];
8204     }
8205     var result = new Array(numErrors);
8206     var errorCount = 0;
8207     for (var i = 1; i < field.size && errorCount < numErrors; i++) {
8208         if (errorLocator.evaluateAt(i) === 0) {
8209             result[errorCount] = field.inverse(i);
8210             errorCount++;
8211         }
8212     }
8213     if (errorCount !== numErrors) {
8214         return null;
8215     }
8216     return result;
8217 }
8218 function findErrorMagnitudes(field, errorEvaluator, errorLocations) {
8219     // This is directly applying Forney's Formula
8220     var s = errorLocations.length;
8221     var result = new Array(s);
8222     for (var i = 0; i < s; i++) {
8223         var xiInverse = field.inverse(errorLocations[i]);
8224         var denominator = 1;
8225         for (var j = 0; j < s; j++) {
8226             if (i !== j) {
8227                 denominator = field.multiply(denominator, GenericGF_1.addOrSubtractGF(1, field.multiply(errorLocations[j], xiInverse)));
8228             }
8229         }
8230         result[i] = field.multiply(errorEvaluator.evaluateAt(xiInverse), field.inverse(denominator));
8231         if (field.generatorBase !== 0) {
8232             result[i] = field.multiply(result[i], xiInverse);
8233         }
8234     }
8235     return result;
8236 }
8237 function decode(bytes, twoS) {
8238     var outputBytes = new Uint8ClampedArray(bytes.length);
8239     outputBytes.set(bytes);
8240     var field = new GenericGF_1.default(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1
8241     var poly = new GenericGFPoly_1.default(field, outputBytes);
8242     var syndromeCoefficients = new Uint8ClampedArray(twoS);
8243     var error = false;
8244     for (var s = 0; s < twoS; s++) {
8245         var evaluation = poly.evaluateAt(field.exp(s + field.generatorBase));
8246         syndromeCoefficients[syndromeCoefficients.length - 1 - s] = evaluation;
8247         if (evaluation !== 0) {
8248             error = true;
8249         }
8250     }
8251     if (!error) {
8252         return outputBytes;
8253     }
8254     var syndrome = new GenericGFPoly_1.default(field, syndromeCoefficients);
8255     var sigmaOmega = runEuclideanAlgorithm(field, field.buildMonomial(twoS, 1), syndrome, twoS);
8256     if (sigmaOmega === null) {
8257         return null;
8258     }
8259     var errorLocations = findErrorLocations(field, sigmaOmega[0]);
8260     if (errorLocations == null) {
8261         return null;
8262     }
8263     var errorMagnitudes = findErrorMagnitudes(field, sigmaOmega[1], errorLocations);
8264     for (var i = 0; i < errorLocations.length; i++) {
8265         var position = outputBytes.length - 1 - field.log(errorLocations[i]);
8266         if (position < 0) {
8267             return null;
8268         }
8269         outputBytes[position] = GenericGF_1.addOrSubtractGF(outputBytes[position], errorMagnitudes[i]);
8270     }
8271     return outputBytes;
8272 }
8273 exports.decode = decode;
8274
8275
8276 /***/ }),
8277 /* 10 */
8278 /***/ (function(module, exports, __webpack_require__) {
8279
8280 "use strict";
8281
8282 Object.defineProperty(exports, "__esModule", { value: true });
8283 exports.VERSIONS = [
8284     {
8285         infoBits: null,
8286         versionNumber: 1,
8287         alignmentPatternCenters: [],
8288         errorCorrectionLevels: [
8289             {
8290                 ecCodewordsPerBlock: 7,
8291                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 19 }],
8292             },
8293             {
8294                 ecCodewordsPerBlock: 10,
8295                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 16 }],
8296             },
8297             {
8298                 ecCodewordsPerBlock: 13,
8299                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 13 }],
8300             },
8301             {
8302                 ecCodewordsPerBlock: 17,
8303                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 9 }],
8304             },
8305         ],
8306     },
8307     {
8308         infoBits: null,
8309         versionNumber: 2,
8310         alignmentPatternCenters: [6, 18],
8311         errorCorrectionLevels: [
8312             {
8313                 ecCodewordsPerBlock: 10,
8314                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 34 }],
8315             },
8316             {
8317                 ecCodewordsPerBlock: 16,
8318                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 28 }],
8319             },
8320             {
8321                 ecCodewordsPerBlock: 22,
8322                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 22 }],
8323             },
8324             {
8325                 ecCodewordsPerBlock: 28,
8326                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 16 }],
8327             },
8328         ],
8329     },
8330     {
8331         infoBits: null,
8332         versionNumber: 3,
8333         alignmentPatternCenters: [6, 22],
8334         errorCorrectionLevels: [
8335             {
8336                 ecCodewordsPerBlock: 15,
8337                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 55 }],
8338             },
8339             {
8340                 ecCodewordsPerBlock: 26,
8341                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 44 }],
8342             },
8343             {
8344                 ecCodewordsPerBlock: 18,
8345                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 17 }],
8346             },
8347             {
8348                 ecCodewordsPerBlock: 22,
8349                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 13 }],
8350             },
8351         ],
8352     },
8353     {
8354         infoBits: null,
8355         versionNumber: 4,
8356         alignmentPatternCenters: [6, 26],
8357         errorCorrectionLevels: [
8358             {
8359                 ecCodewordsPerBlock: 20,
8360                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 80 }],
8361             },
8362             {
8363                 ecCodewordsPerBlock: 18,
8364                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 32 }],
8365             },
8366             {
8367                 ecCodewordsPerBlock: 26,
8368                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 24 }],
8369             },
8370             {
8371                 ecCodewordsPerBlock: 16,
8372                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 9 }],
8373             },
8374         ],
8375     },
8376     {
8377         infoBits: null,
8378         versionNumber: 5,
8379         alignmentPatternCenters: [6, 30],
8380         errorCorrectionLevels: [
8381             {
8382                 ecCodewordsPerBlock: 26,
8383                 ecBlocks: [{ numBlocks: 1, dataCodewordsPerBlock: 108 }],
8384             },
8385             {
8386                 ecCodewordsPerBlock: 24,
8387                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 43 }],
8388             },
8389             {
8390                 ecCodewordsPerBlock: 18,
8391                 ecBlocks: [
8392                     { numBlocks: 2, dataCodewordsPerBlock: 15 },
8393                     { numBlocks: 2, dataCodewordsPerBlock: 16 },
8394                 ],
8395             },
8396             {
8397                 ecCodewordsPerBlock: 22,
8398                 ecBlocks: [
8399                     { numBlocks: 2, dataCodewordsPerBlock: 11 },
8400                     { numBlocks: 2, dataCodewordsPerBlock: 12 },
8401                 ],
8402             },
8403         ],
8404     },
8405     {
8406         infoBits: null,
8407         versionNumber: 6,
8408         alignmentPatternCenters: [6, 34],
8409         errorCorrectionLevels: [
8410             {
8411                 ecCodewordsPerBlock: 18,
8412                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 68 }],
8413             },
8414             {
8415                 ecCodewordsPerBlock: 16,
8416                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 27 }],
8417             },
8418             {
8419                 ecCodewordsPerBlock: 24,
8420                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 19 }],
8421             },
8422             {
8423                 ecCodewordsPerBlock: 28,
8424                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 15 }],
8425             },
8426         ],
8427     },
8428     {
8429         infoBits: 0x07C94,
8430         versionNumber: 7,
8431         alignmentPatternCenters: [6, 22, 38],
8432         errorCorrectionLevels: [
8433             {
8434                 ecCodewordsPerBlock: 20,
8435                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 78 }],
8436             },
8437             {
8438                 ecCodewordsPerBlock: 18,
8439                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 31 }],
8440             },
8441             {
8442                 ecCodewordsPerBlock: 18,
8443                 ecBlocks: [
8444                     { numBlocks: 2, dataCodewordsPerBlock: 14 },
8445                     { numBlocks: 4, dataCodewordsPerBlock: 15 },
8446                 ],
8447             },
8448             {
8449                 ecCodewordsPerBlock: 26,
8450                 ecBlocks: [
8451                     { numBlocks: 4, dataCodewordsPerBlock: 13 },
8452                     { numBlocks: 1, dataCodewordsPerBlock: 14 },
8453                 ],
8454             },
8455         ],
8456     },
8457     {
8458         infoBits: 0x085BC,
8459         versionNumber: 8,
8460         alignmentPatternCenters: [6, 24, 42],
8461         errorCorrectionLevels: [
8462             {
8463                 ecCodewordsPerBlock: 24,
8464                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 97 }],
8465             },
8466             {
8467                 ecCodewordsPerBlock: 22,
8468                 ecBlocks: [
8469                     { numBlocks: 2, dataCodewordsPerBlock: 38 },
8470                     { numBlocks: 2, dataCodewordsPerBlock: 39 },
8471                 ],
8472             },
8473             {
8474                 ecCodewordsPerBlock: 22,
8475                 ecBlocks: [
8476                     { numBlocks: 4, dataCodewordsPerBlock: 18 },
8477                     { numBlocks: 2, dataCodewordsPerBlock: 19 },
8478                 ],
8479             },
8480             {
8481                 ecCodewordsPerBlock: 26,
8482                 ecBlocks: [
8483                     { numBlocks: 4, dataCodewordsPerBlock: 14 },
8484                     { numBlocks: 2, dataCodewordsPerBlock: 15 },
8485                 ],
8486             },
8487         ],
8488     },
8489     {
8490         infoBits: 0x09A99,
8491         versionNumber: 9,
8492         alignmentPatternCenters: [6, 26, 46],
8493         errorCorrectionLevels: [
8494             {
8495                 ecCodewordsPerBlock: 30,
8496                 ecBlocks: [{ numBlocks: 2, dataCodewordsPerBlock: 116 }],
8497             },
8498             {
8499                 ecCodewordsPerBlock: 22,
8500                 ecBlocks: [
8501                     { numBlocks: 3, dataCodewordsPerBlock: 36 },
8502                     { numBlocks: 2, dataCodewordsPerBlock: 37 },
8503                 ],
8504             },
8505             {
8506                 ecCodewordsPerBlock: 20,
8507                 ecBlocks: [
8508                     { numBlocks: 4, dataCodewordsPerBlock: 16 },
8509                     { numBlocks: 4, dataCodewordsPerBlock: 17 },
8510                 ],
8511             },
8512             {
8513                 ecCodewordsPerBlock: 24,
8514                 ecBlocks: [
8515                     { numBlocks: 4, dataCodewordsPerBlock: 12 },
8516                     { numBlocks: 4, dataCodewordsPerBlock: 13 },
8517                 ],
8518             },
8519         ],
8520     },
8521     {
8522         infoBits: 0x0A4D3,
8523         versionNumber: 10,
8524         alignmentPatternCenters: [6, 28, 50],
8525         errorCorrectionLevels: [
8526             {
8527                 ecCodewordsPerBlock: 18,
8528                 ecBlocks: [
8529                     { numBlocks: 2, dataCodewordsPerBlock: 68 },
8530                     { numBlocks: 2, dataCodewordsPerBlock: 69 },
8531                 ],
8532             },
8533             {
8534                 ecCodewordsPerBlock: 26,
8535                 ecBlocks: [
8536                     { numBlocks: 4, dataCodewordsPerBlock: 43 },
8537                     { numBlocks: 1, dataCodewordsPerBlock: 44 },
8538                 ],
8539             },
8540             {
8541                 ecCodewordsPerBlock: 24,
8542                 ecBlocks: [
8543                     { numBlocks: 6, dataCodewordsPerBlock: 19 },
8544                     { numBlocks: 2, dataCodewordsPerBlock: 20 },
8545                 ],
8546             },
8547             {
8548                 ecCodewordsPerBlock: 28,
8549                 ecBlocks: [
8550                     { numBlocks: 6, dataCodewordsPerBlock: 15 },
8551                     { numBlocks: 2, dataCodewordsPerBlock: 16 },
8552                 ],
8553             },
8554         ],
8555     },
8556     {
8557         infoBits: 0x0BBF6,
8558         versionNumber: 11,
8559         alignmentPatternCenters: [6, 30, 54],
8560         errorCorrectionLevels: [
8561             {
8562                 ecCodewordsPerBlock: 20,
8563                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 81 }],
8564             },
8565             {
8566                 ecCodewordsPerBlock: 30,
8567                 ecBlocks: [
8568                     { numBlocks: 1, dataCodewordsPerBlock: 50 },
8569                     { numBlocks: 4, dataCodewordsPerBlock: 51 },
8570                 ],
8571             },
8572             {
8573                 ecCodewordsPerBlock: 28,
8574                 ecBlocks: [
8575                     { numBlocks: 4, dataCodewordsPerBlock: 22 },
8576                     { numBlocks: 4, dataCodewordsPerBlock: 23 },
8577                 ],
8578             },
8579             {
8580                 ecCodewordsPerBlock: 24,
8581                 ecBlocks: [
8582                     { numBlocks: 3, dataCodewordsPerBlock: 12 },
8583                     { numBlocks: 8, dataCodewordsPerBlock: 13 },
8584                 ],
8585             },
8586         ],
8587     },
8588     {
8589         infoBits: 0x0C762,
8590         versionNumber: 12,
8591         alignmentPatternCenters: [6, 32, 58],
8592         errorCorrectionLevels: [
8593             {
8594                 ecCodewordsPerBlock: 24,
8595                 ecBlocks: [
8596                     { numBlocks: 2, dataCodewordsPerBlock: 92 },
8597                     { numBlocks: 2, dataCodewordsPerBlock: 93 },
8598                 ],
8599             },
8600             {
8601                 ecCodewordsPerBlock: 22,
8602                 ecBlocks: [
8603                     { numBlocks: 6, dataCodewordsPerBlock: 36 },
8604                     { numBlocks: 2, dataCodewordsPerBlock: 37 },
8605                 ],
8606             },
8607             {
8608                 ecCodewordsPerBlock: 26,
8609                 ecBlocks: [
8610                     { numBlocks: 4, dataCodewordsPerBlock: 20 },
8611                     { numBlocks: 6, dataCodewordsPerBlock: 21 },
8612                 ],
8613             },
8614             {
8615                 ecCodewordsPerBlock: 28,
8616                 ecBlocks: [
8617                     { numBlocks: 7, dataCodewordsPerBlock: 14 },
8618                     { numBlocks: 4, dataCodewordsPerBlock: 15 },
8619                 ],
8620             },
8621         ],
8622     },
8623     {
8624         infoBits: 0x0D847,
8625         versionNumber: 13,
8626         alignmentPatternCenters: [6, 34, 62],
8627         errorCorrectionLevels: [
8628             {
8629                 ecCodewordsPerBlock: 26,
8630                 ecBlocks: [{ numBlocks: 4, dataCodewordsPerBlock: 107 }],
8631             },
8632             {
8633                 ecCodewordsPerBlock: 22,
8634                 ecBlocks: [
8635                     { numBlocks: 8, dataCodewordsPerBlock: 37 },
8636                     { numBlocks: 1, dataCodewordsPerBlock: 38 },
8637                 ],
8638             },
8639             {
8640                 ecCodewordsPerBlock: 24,
8641                 ecBlocks: [
8642                     { numBlocks: 8, dataCodewordsPerBlock: 20 },
8643                     { numBlocks: 4, dataCodewordsPerBlock: 21 },
8644                 ],
8645             },
8646             {
8647                 ecCodewordsPerBlock: 22,
8648                 ecBlocks: [
8649                     { numBlocks: 12, dataCodewordsPerBlock: 11 },
8650                     { numBlocks: 4, dataCodewordsPerBlock: 12 },
8651                 ],
8652             },
8653         ],
8654     },
8655     {
8656         infoBits: 0x0E60D,
8657         versionNumber: 14,
8658         alignmentPatternCenters: [6, 26, 46, 66],
8659         errorCorrectionLevels: [
8660             {
8661                 ecCodewordsPerBlock: 30,
8662                 ecBlocks: [
8663                     { numBlocks: 3, dataCodewordsPerBlock: 115 },
8664                     { numBlocks: 1, dataCodewordsPerBlock: 116 },
8665                 ],
8666             },
8667             {
8668                 ecCodewordsPerBlock: 24,
8669                 ecBlocks: [
8670                     { numBlocks: 4, dataCodewordsPerBlock: 40 },
8671                     { numBlocks: 5, dataCodewordsPerBlock: 41 },
8672                 ],
8673             },
8674             {
8675                 ecCodewordsPerBlock: 20,
8676                 ecBlocks: [
8677                     { numBlocks: 11, dataCodewordsPerBlock: 16 },
8678                     { numBlocks: 5, dataCodewordsPerBlock: 17 },
8679                 ],
8680             },
8681             {
8682                 ecCodewordsPerBlock: 24,
8683                 ecBlocks: [
8684                     { numBlocks: 11, dataCodewordsPerBlock: 12 },
8685                     { numBlocks: 5, dataCodewordsPerBlock: 13 },
8686                 ],
8687             },
8688         ],
8689     },
8690     {
8691         infoBits: 0x0F928,
8692         versionNumber: 15,
8693         alignmentPatternCenters: [6, 26, 48, 70],
8694         errorCorrectionLevels: [
8695             {
8696                 ecCodewordsPerBlock: 22,
8697                 ecBlocks: [
8698                     { numBlocks: 5, dataCodewordsPerBlock: 87 },
8699                     { numBlocks: 1, dataCodewordsPerBlock: 88 },
8700                 ],
8701             },
8702             {
8703                 ecCodewordsPerBlock: 24,
8704                 ecBlocks: [
8705                     { numBlocks: 5, dataCodewordsPerBlock: 41 },
8706                     { numBlocks: 5, dataCodewordsPerBlock: 42 },
8707                 ],
8708             },
8709             {
8710                 ecCodewordsPerBlock: 30,
8711                 ecBlocks: [
8712                     { numBlocks: 5, dataCodewordsPerBlock: 24 },
8713                     { numBlocks: 7, dataCodewordsPerBlock: 25 },
8714                 ],
8715             },
8716             {
8717                 ecCodewordsPerBlock: 24,
8718                 ecBlocks: [
8719                     { numBlocks: 11, dataCodewordsPerBlock: 12 },
8720                     { numBlocks: 7, dataCodewordsPerBlock: 13 },
8721                 ],
8722             },
8723         ],
8724     },
8725     {
8726         infoBits: 0x10B78,
8727         versionNumber: 16,
8728         alignmentPatternCenters: [6, 26, 50, 74],
8729         errorCorrectionLevels: [
8730             {
8731                 ecCodewordsPerBlock: 24,
8732                 ecBlocks: [
8733                     { numBlocks: 5, dataCodewordsPerBlock: 98 },
8734                     { numBlocks: 1, dataCodewordsPerBlock: 99 },
8735                 ],
8736             },
8737             {
8738                 ecCodewordsPerBlock: 28,
8739                 ecBlocks: [
8740                     { numBlocks: 7, dataCodewordsPerBlock: 45 },
8741                     { numBlocks: 3, dataCodewordsPerBlock: 46 },
8742                 ],
8743             },
8744             {
8745                 ecCodewordsPerBlock: 24,
8746                 ecBlocks: [
8747                     { numBlocks: 15, dataCodewordsPerBlock: 19 },
8748                     { numBlocks: 2, dataCodewordsPerBlock: 20 },
8749                 ],
8750             },
8751             {
8752                 ecCodewordsPerBlock: 30,
8753                 ecBlocks: [
8754                     { numBlocks: 3, dataCodewordsPerBlock: 15 },
8755                     { numBlocks: 13, dataCodewordsPerBlock: 16 },
8756                 ],
8757             },
8758         ],
8759     },
8760     {
8761         infoBits: 0x1145D,
8762         versionNumber: 17,
8763         alignmentPatternCenters: [6, 30, 54, 78],
8764         errorCorrectionLevels: [
8765             {
8766                 ecCodewordsPerBlock: 28,
8767                 ecBlocks: [
8768                     { numBlocks: 1, dataCodewordsPerBlock: 107 },
8769                     { numBlocks: 5, dataCodewordsPerBlock: 108 },
8770                 ],
8771             },
8772             {
8773                 ecCodewordsPerBlock: 28,
8774                 ecBlocks: [
8775                     { numBlocks: 10, dataCodewordsPerBlock: 46 },
8776                     { numBlocks: 1, dataCodewordsPerBlock: 47 },
8777                 ],
8778             },
8779             {
8780                 ecCodewordsPerBlock: 28,
8781                 ecBlocks: [
8782                     { numBlocks: 1, dataCodewordsPerBlock: 22 },
8783                     { numBlocks: 15, dataCodewordsPerBlock: 23 },
8784                 ],
8785             },
8786             {
8787                 ecCodewordsPerBlock: 28,
8788                 ecBlocks: [
8789                     { numBlocks: 2, dataCodewordsPerBlock: 14 },
8790                     { numBlocks: 17, dataCodewordsPerBlock: 15 },
8791                 ],
8792             },
8793         ],
8794     },
8795     {
8796         infoBits: 0x12A17,
8797         versionNumber: 18,
8798         alignmentPatternCenters: [6, 30, 56, 82],
8799         errorCorrectionLevels: [
8800             {
8801                 ecCodewordsPerBlock: 30,
8802                 ecBlocks: [
8803                     { numBlocks: 5, dataCodewordsPerBlock: 120 },
8804                     { numBlocks: 1, dataCodewordsPerBlock: 121 },
8805                 ],
8806             },
8807             {
8808                 ecCodewordsPerBlock: 26,
8809                 ecBlocks: [
8810                     { numBlocks: 9, dataCodewordsPerBlock: 43 },
8811                     { numBlocks: 4, dataCodewordsPerBlock: 44 },
8812                 ],
8813             },
8814             {
8815                 ecCodewordsPerBlock: 28,
8816                 ecBlocks: [
8817                     { numBlocks: 17, dataCodewordsPerBlock: 22 },
8818                     { numBlocks: 1, dataCodewordsPerBlock: 23 },
8819                 ],
8820             },
8821             {
8822                 ecCodewordsPerBlock: 28,
8823                 ecBlocks: [
8824                     { numBlocks: 2, dataCodewordsPerBlock: 14 },
8825                     { numBlocks: 19, dataCodewordsPerBlock: 15 },
8826                 ],
8827             },
8828         ],
8829     },
8830     {
8831         infoBits: 0x13532,
8832         versionNumber: 19,
8833         alignmentPatternCenters: [6, 30, 58, 86],
8834         errorCorrectionLevels: [
8835             {
8836                 ecCodewordsPerBlock: 28,
8837                 ecBlocks: [
8838                     { numBlocks: 3, dataCodewordsPerBlock: 113 },
8839                     { numBlocks: 4, dataCodewordsPerBlock: 114 },
8840                 ],
8841             },
8842             {
8843                 ecCodewordsPerBlock: 26,
8844                 ecBlocks: [
8845                     { numBlocks: 3, dataCodewordsPerBlock: 44 },
8846                     { numBlocks: 11, dataCodewordsPerBlock: 45 },
8847                 ],
8848             },
8849             {
8850                 ecCodewordsPerBlock: 26,
8851                 ecBlocks: [
8852                     { numBlocks: 17, dataCodewordsPerBlock: 21 },
8853                     { numBlocks: 4, dataCodewordsPerBlock: 22 },
8854                 ],
8855             },
8856             {
8857                 ecCodewordsPerBlock: 26,
8858                 ecBlocks: [
8859                     { numBlocks: 9, dataCodewordsPerBlock: 13 },
8860                     { numBlocks: 16, dataCodewordsPerBlock: 14 },
8861                 ],
8862             },
8863         ],
8864     },
8865     {
8866         infoBits: 0x149A6,
8867         versionNumber: 20,
8868         alignmentPatternCenters: [6, 34, 62, 90],
8869         errorCorrectionLevels: [
8870             {
8871                 ecCodewordsPerBlock: 28,
8872                 ecBlocks: [
8873                     { numBlocks: 3, dataCodewordsPerBlock: 107 },
8874                     { numBlocks: 5, dataCodewordsPerBlock: 108 },
8875                 ],
8876             },
8877             {
8878                 ecCodewordsPerBlock: 26,
8879                 ecBlocks: [
8880                     { numBlocks: 3, dataCodewordsPerBlock: 41 },
8881                     { numBlocks: 13, dataCodewordsPerBlock: 42 },
8882                 ],
8883             },
8884             {
8885                 ecCodewordsPerBlock: 30,
8886                 ecBlocks: [
8887                     { numBlocks: 15, dataCodewordsPerBlock: 24 },
8888                     { numBlocks: 5, dataCodewordsPerBlock: 25 },
8889                 ],
8890             },
8891             {
8892                 ecCodewordsPerBlock: 28,
8893                 ecBlocks: [
8894                     { numBlocks: 15, dataCodewordsPerBlock: 15 },
8895                     { numBlocks: 10, dataCodewordsPerBlock: 16 },
8896                 ],
8897             },
8898         ],
8899     },
8900     {
8901         infoBits: 0x15683,
8902         versionNumber: 21,
8903         alignmentPatternCenters: [6, 28, 50, 72, 94],
8904         errorCorrectionLevels: [
8905             {
8906                 ecCodewordsPerBlock: 28,
8907                 ecBlocks: [
8908                     { numBlocks: 4, dataCodewordsPerBlock: 116 },
8909                     { numBlocks: 4, dataCodewordsPerBlock: 117 },
8910                 ],
8911             },
8912             {
8913                 ecCodewordsPerBlock: 26,
8914                 ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 42 }],
8915             },
8916             {
8917                 ecCodewordsPerBlock: 28,
8918                 ecBlocks: [
8919                     { numBlocks: 17, dataCodewordsPerBlock: 22 },
8920                     { numBlocks: 6, dataCodewordsPerBlock: 23 },
8921                 ],
8922             },
8923             {
8924                 ecCodewordsPerBlock: 30,
8925                 ecBlocks: [
8926                     { numBlocks: 19, dataCodewordsPerBlock: 16 },
8927                     { numBlocks: 6, dataCodewordsPerBlock: 17 },
8928                 ],
8929             },
8930         ],
8931     },
8932     {
8933         infoBits: 0x168C9,
8934         versionNumber: 22,
8935         alignmentPatternCenters: [6, 26, 50, 74, 98],
8936         errorCorrectionLevels: [
8937             {
8938                 ecCodewordsPerBlock: 28,
8939                 ecBlocks: [
8940                     { numBlocks: 2, dataCodewordsPerBlock: 111 },
8941                     { numBlocks: 7, dataCodewordsPerBlock: 112 },
8942                 ],
8943             },
8944             {
8945                 ecCodewordsPerBlock: 28,
8946                 ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 46 }],
8947             },
8948             {
8949                 ecCodewordsPerBlock: 30,
8950                 ecBlocks: [
8951                     { numBlocks: 7, dataCodewordsPerBlock: 24 },
8952                     { numBlocks: 16, dataCodewordsPerBlock: 25 },
8953                 ],
8954             },
8955             {
8956                 ecCodewordsPerBlock: 24,
8957                 ecBlocks: [{ numBlocks: 34, dataCodewordsPerBlock: 13 }],
8958             },
8959         ],
8960     },
8961     {
8962         infoBits: 0x177EC,
8963         versionNumber: 23,
8964         alignmentPatternCenters: [6, 30, 54, 74, 102],
8965         errorCorrectionLevels: [
8966             {
8967                 ecCodewordsPerBlock: 30,
8968                 ecBlocks: [
8969                     { numBlocks: 4, dataCodewordsPerBlock: 121 },
8970                     { numBlocks: 5, dataCodewordsPerBlock: 122 },
8971                 ],
8972             },
8973             {
8974                 ecCodewordsPerBlock: 28,
8975                 ecBlocks: [
8976                     { numBlocks: 4, dataCodewordsPerBlock: 47 },
8977                     { numBlocks: 14, dataCodewordsPerBlock: 48 },
8978                 ],
8979             },
8980             {
8981                 ecCodewordsPerBlock: 30,
8982                 ecBlocks: [
8983                     { numBlocks: 11, dataCodewordsPerBlock: 24 },
8984                     { numBlocks: 14, dataCodewordsPerBlock: 25 },
8985                 ],
8986             },
8987             {
8988                 ecCodewordsPerBlock: 30,
8989                 ecBlocks: [
8990                     { numBlocks: 16, dataCodewordsPerBlock: 15 },
8991                     { numBlocks: 14, dataCodewordsPerBlock: 16 },
8992                 ],
8993             },
8994         ],
8995     },
8996     {
8997         infoBits: 0x18EC4,
8998         versionNumber: 24,
8999         alignmentPatternCenters: [6, 28, 54, 80, 106],
9000         errorCorrectionLevels: [
9001             {
9002                 ecCodewordsPerBlock: 30,
9003                 ecBlocks: [
9004                     { numBlocks: 6, dataCodewordsPerBlock: 117 },
9005                     { numBlocks: 4, dataCodewordsPerBlock: 118 },
9006                 ],
9007             },
9008             {
9009                 ecCodewordsPerBlock: 28,
9010                 ecBlocks: [
9011                     { numBlocks: 6, dataCodewordsPerBlock: 45 },
9012                     { numBlocks: 14, dataCodewordsPerBlock: 46 },
9013                 ],
9014             },
9015             {
9016                 ecCodewordsPerBlock: 30,
9017                 ecBlocks: [
9018                     { numBlocks: 11, dataCodewordsPerBlock: 24 },
9019                     { numBlocks: 16, dataCodewordsPerBlock: 25 },
9020                 ],
9021             },
9022             {
9023                 ecCodewordsPerBlock: 30,
9024                 ecBlocks: [
9025                     { numBlocks: 30, dataCodewordsPerBlock: 16 },
9026                     { numBlocks: 2, dataCodewordsPerBlock: 17 },
9027                 ],
9028             },
9029         ],
9030     },
9031     {
9032         infoBits: 0x191E1,
9033         versionNumber: 25,
9034         alignmentPatternCenters: [6, 32, 58, 84, 110],
9035         errorCorrectionLevels: [
9036             {
9037                 ecCodewordsPerBlock: 26,
9038                 ecBlocks: [
9039                     { numBlocks: 8, dataCodewordsPerBlock: 106 },
9040                     { numBlocks: 4, dataCodewordsPerBlock: 107 },
9041                 ],
9042             },
9043             {
9044                 ecCodewordsPerBlock: 28,
9045                 ecBlocks: [
9046                     { numBlocks: 8, dataCodewordsPerBlock: 47 },
9047                     { numBlocks: 13, dataCodewordsPerBlock: 48 },
9048                 ],
9049             },
9050             {
9051                 ecCodewordsPerBlock: 30,
9052                 ecBlocks: [
9053                     { numBlocks: 7, dataCodewordsPerBlock: 24 },
9054                     { numBlocks: 22, dataCodewordsPerBlock: 25 },
9055                 ],
9056             },
9057             {
9058                 ecCodewordsPerBlock: 30,
9059                 ecBlocks: [
9060                     { numBlocks: 22, dataCodewordsPerBlock: 15 },
9061                     { numBlocks: 13, dataCodewordsPerBlock: 16 },
9062                 ],
9063             },
9064         ],
9065     },
9066     {
9067         infoBits: 0x1AFAB,
9068         versionNumber: 26,
9069         alignmentPatternCenters: [6, 30, 58, 86, 114],
9070         errorCorrectionLevels: [
9071             {
9072                 ecCodewordsPerBlock: 28,
9073                 ecBlocks: [
9074                     { numBlocks: 10, dataCodewordsPerBlock: 114 },
9075                     { numBlocks: 2, dataCodewordsPerBlock: 115 },
9076                 ],
9077             },
9078             {
9079                 ecCodewordsPerBlock: 28,
9080                 ecBlocks: [
9081                     { numBlocks: 19, dataCodewordsPerBlock: 46 },
9082                     { numBlocks: 4, dataCodewordsPerBlock: 47 },
9083                 ],
9084             },
9085             {
9086                 ecCodewordsPerBlock: 28,
9087                 ecBlocks: [
9088                     { numBlocks: 28, dataCodewordsPerBlock: 22 },
9089                     { numBlocks: 6, dataCodewordsPerBlock: 23 },
9090                 ],
9091             },
9092             {
9093                 ecCodewordsPerBlock: 30,
9094                 ecBlocks: [
9095                     { numBlocks: 33, dataCodewordsPerBlock: 16 },
9096                     { numBlocks: 4, dataCodewordsPerBlock: 17 },
9097                 ],
9098             },
9099         ],
9100     },
9101     {
9102         infoBits: 0x1B08E,
9103         versionNumber: 27,
9104         alignmentPatternCenters: [6, 34, 62, 90, 118],
9105         errorCorrectionLevels: [
9106             {
9107                 ecCodewordsPerBlock: 30,
9108                 ecBlocks: [
9109                     { numBlocks: 8, dataCodewordsPerBlock: 122 },
9110                     { numBlocks: 4, dataCodewordsPerBlock: 123 },
9111                 ],
9112             },
9113             {
9114                 ecCodewordsPerBlock: 28,
9115                 ecBlocks: [
9116                     { numBlocks: 22, dataCodewordsPerBlock: 45 },
9117                     { numBlocks: 3, dataCodewordsPerBlock: 46 },
9118                 ],
9119             },
9120             {
9121                 ecCodewordsPerBlock: 30,
9122                 ecBlocks: [
9123                     { numBlocks: 8, dataCodewordsPerBlock: 23 },
9124                     { numBlocks: 26, dataCodewordsPerBlock: 24 },
9125                 ],
9126             },
9127             {
9128                 ecCodewordsPerBlock: 30,
9129                 ecBlocks: [
9130                     { numBlocks: 12, dataCodewordsPerBlock: 15 },
9131                     { numBlocks: 28, dataCodewordsPerBlock: 16 },
9132                 ],
9133             },
9134         ],
9135     },
9136     {
9137         infoBits: 0x1CC1A,
9138         versionNumber: 28,
9139         alignmentPatternCenters: [6, 26, 50, 74, 98, 122],
9140         errorCorrectionLevels: [
9141             {
9142                 ecCodewordsPerBlock: 30,
9143                 ecBlocks: [
9144                     { numBlocks: 3, dataCodewordsPerBlock: 117 },
9145                     { numBlocks: 10, dataCodewordsPerBlock: 118 },
9146                 ],
9147             },
9148             {
9149                 ecCodewordsPerBlock: 28,
9150                 ecBlocks: [
9151                     { numBlocks: 3, dataCodewordsPerBlock: 45 },
9152                     { numBlocks: 23, dataCodewordsPerBlock: 46 },
9153                 ],
9154             },
9155             {
9156                 ecCodewordsPerBlock: 30,
9157                 ecBlocks: [
9158                     { numBlocks: 4, dataCodewordsPerBlock: 24 },
9159                     { numBlocks: 31, dataCodewordsPerBlock: 25 },
9160                 ],
9161             },
9162             {
9163                 ecCodewordsPerBlock: 30,
9164                 ecBlocks: [
9165                     { numBlocks: 11, dataCodewordsPerBlock: 15 },
9166                     { numBlocks: 31, dataCodewordsPerBlock: 16 },
9167                 ],
9168             },
9169         ],
9170     },
9171     {
9172         infoBits: 0x1D33F,
9173         versionNumber: 29,
9174         alignmentPatternCenters: [6, 30, 54, 78, 102, 126],
9175         errorCorrectionLevels: [
9176             {
9177                 ecCodewordsPerBlock: 30,
9178                 ecBlocks: [
9179                     { numBlocks: 7, dataCodewordsPerBlock: 116 },
9180                     { numBlocks: 7, dataCodewordsPerBlock: 117 },
9181                 ],
9182             },
9183             {
9184                 ecCodewordsPerBlock: 28,
9185                 ecBlocks: [
9186                     { numBlocks: 21, dataCodewordsPerBlock: 45 },
9187                     { numBlocks: 7, dataCodewordsPerBlock: 46 },
9188                 ],
9189             },
9190             {
9191                 ecCodewordsPerBlock: 30,
9192                 ecBlocks: [
9193                     { numBlocks: 1, dataCodewordsPerBlock: 23 },
9194                     { numBlocks: 37, dataCodewordsPerBlock: 24 },
9195                 ],
9196             },
9197             {
9198                 ecCodewordsPerBlock: 30,
9199                 ecBlocks: [
9200                     { numBlocks: 19, dataCodewordsPerBlock: 15 },
9201                     { numBlocks: 26, dataCodewordsPerBlock: 16 },
9202                 ],
9203             },
9204         ],
9205     },
9206     {
9207         infoBits: 0x1ED75,
9208         versionNumber: 30,
9209         alignmentPatternCenters: [6, 26, 52, 78, 104, 130],
9210         errorCorrectionLevels: [
9211             {
9212                 ecCodewordsPerBlock: 30,
9213                 ecBlocks: [
9214                     { numBlocks: 5, dataCodewordsPerBlock: 115 },
9215                     { numBlocks: 10, dataCodewordsPerBlock: 116 },
9216                 ],
9217             },
9218             {
9219                 ecCodewordsPerBlock: 28,
9220                 ecBlocks: [
9221                     { numBlocks: 19, dataCodewordsPerBlock: 47 },
9222                     { numBlocks: 10, dataCodewordsPerBlock: 48 },
9223                 ],
9224             },
9225             {
9226                 ecCodewordsPerBlock: 30,
9227                 ecBlocks: [
9228                     { numBlocks: 15, dataCodewordsPerBlock: 24 },
9229                     { numBlocks: 25, dataCodewordsPerBlock: 25 },
9230                 ],
9231             },
9232             {
9233                 ecCodewordsPerBlock: 30,
9234                 ecBlocks: [
9235                     { numBlocks: 23, dataCodewordsPerBlock: 15 },
9236                     { numBlocks: 25, dataCodewordsPerBlock: 16 },
9237                 ],
9238             },
9239         ],
9240     },
9241     {
9242         infoBits: 0x1F250,
9243         versionNumber: 31,
9244         alignmentPatternCenters: [6, 30, 56, 82, 108, 134],
9245         errorCorrectionLevels: [
9246             {
9247                 ecCodewordsPerBlock: 30,
9248                 ecBlocks: [
9249                     { numBlocks: 13, dataCodewordsPerBlock: 115 },
9250                     { numBlocks: 3, dataCodewordsPerBlock: 116 },
9251                 ],
9252             },
9253             {
9254                 ecCodewordsPerBlock: 28,
9255                 ecBlocks: [
9256                     { numBlocks: 2, dataCodewordsPerBlock: 46 },
9257                     { numBlocks: 29, dataCodewordsPerBlock: 47 },
9258                 ],
9259             },
9260             {
9261                 ecCodewordsPerBlock: 30,
9262                 ecBlocks: [
9263                     { numBlocks: 42, dataCodewordsPerBlock: 24 },
9264                     { numBlocks: 1, dataCodewordsPerBlock: 25 },
9265                 ],
9266             },
9267             {
9268                 ecCodewordsPerBlock: 30,
9269                 ecBlocks: [
9270                     { numBlocks: 23, dataCodewordsPerBlock: 15 },
9271                     { numBlocks: 28, dataCodewordsPerBlock: 16 },
9272                 ],
9273             },
9274         ],
9275     },
9276     {
9277         infoBits: 0x209D5,
9278         versionNumber: 32,
9279         alignmentPatternCenters: [6, 34, 60, 86, 112, 138],
9280         errorCorrectionLevels: [
9281             {
9282                 ecCodewordsPerBlock: 30,
9283                 ecBlocks: [{ numBlocks: 17, dataCodewordsPerBlock: 115 }],
9284             },
9285             {
9286                 ecCodewordsPerBlock: 28,
9287                 ecBlocks: [
9288                     { numBlocks: 10, dataCodewordsPerBlock: 46 },
9289                     { numBlocks: 23, dataCodewordsPerBlock: 47 },
9290                 ],
9291             },
9292             {
9293                 ecCodewordsPerBlock: 30,
9294                 ecBlocks: [
9295                     { numBlocks: 10, dataCodewordsPerBlock: 24 },
9296                     { numBlocks: 35, dataCodewordsPerBlock: 25 },
9297                 ],
9298             },
9299             {
9300                 ecCodewordsPerBlock: 30,
9301                 ecBlocks: [
9302                     { numBlocks: 19, dataCodewordsPerBlock: 15 },
9303                     { numBlocks: 35, dataCodewordsPerBlock: 16 },
9304                 ],
9305             },
9306         ],
9307     },
9308     {
9309         infoBits: 0x216F0,
9310         versionNumber: 33,
9311         alignmentPatternCenters: [6, 30, 58, 86, 114, 142],
9312         errorCorrectionLevels: [
9313             {
9314                 ecCodewordsPerBlock: 30,
9315                 ecBlocks: [
9316                     { numBlocks: 17, dataCodewordsPerBlock: 115 },
9317                     { numBlocks: 1, dataCodewordsPerBlock: 116 },
9318                 ],
9319             },
9320             {
9321                 ecCodewordsPerBlock: 28,
9322                 ecBlocks: [
9323                     { numBlocks: 14, dataCodewordsPerBlock: 46 },
9324                     { numBlocks: 21, dataCodewordsPerBlock: 47 },
9325                 ],
9326             },
9327             {
9328                 ecCodewordsPerBlock: 30,
9329                 ecBlocks: [
9330                     { numBlocks: 29, dataCodewordsPerBlock: 24 },
9331                     { numBlocks: 19, dataCodewordsPerBlock: 25 },
9332                 ],
9333             },
9334             {
9335                 ecCodewordsPerBlock: 30,
9336                 ecBlocks: [
9337                     { numBlocks: 11, dataCodewordsPerBlock: 15 },
9338                     { numBlocks: 46, dataCodewordsPerBlock: 16 },
9339                 ],
9340             },
9341         ],
9342     },
9343     {
9344         infoBits: 0x228BA,
9345         versionNumber: 34,
9346         alignmentPatternCenters: [6, 34, 62, 90, 118, 146],
9347         errorCorrectionLevels: [
9348             {
9349                 ecCodewordsPerBlock: 30,
9350                 ecBlocks: [
9351                     { numBlocks: 13, dataCodewordsPerBlock: 115 },
9352                     { numBlocks: 6, dataCodewordsPerBlock: 116 },
9353                 ],
9354             },
9355             {
9356                 ecCodewordsPerBlock: 28,
9357                 ecBlocks: [
9358                     { numBlocks: 14, dataCodewordsPerBlock: 46 },
9359                     { numBlocks: 23, dataCodewordsPerBlock: 47 },
9360                 ],
9361             },
9362             {
9363                 ecCodewordsPerBlock: 30,
9364                 ecBlocks: [
9365                     { numBlocks: 44, dataCodewordsPerBlock: 24 },
9366                     { numBlocks: 7, dataCodewordsPerBlock: 25 },
9367                 ],
9368             },
9369             {
9370                 ecCodewordsPerBlock: 30,
9371                 ecBlocks: [
9372                     { numBlocks: 59, dataCodewordsPerBlock: 16 },
9373                     { numBlocks: 1, dataCodewordsPerBlock: 17 },
9374                 ],
9375             },
9376         ],
9377     },
9378     {
9379         infoBits: 0x2379F,
9380         versionNumber: 35,
9381         alignmentPatternCenters: [6, 30, 54, 78, 102, 126, 150],
9382         errorCorrectionLevels: [
9383             {
9384                 ecCodewordsPerBlock: 30,
9385                 ecBlocks: [
9386                     { numBlocks: 12, dataCodewordsPerBlock: 121 },
9387                     { numBlocks: 7, dataCodewordsPerBlock: 122 },
9388                 ],
9389             },
9390             {
9391                 ecCodewordsPerBlock: 28,
9392                 ecBlocks: [
9393                     { numBlocks: 12, dataCodewordsPerBlock: 47 },
9394                     { numBlocks: 26, dataCodewordsPerBlock: 48 },
9395                 ],
9396             },
9397             {
9398                 ecCodewordsPerBlock: 30,
9399                 ecBlocks: [
9400                     { numBlocks: 39, dataCodewordsPerBlock: 24 },
9401                     { numBlocks: 14, dataCodewordsPerBlock: 25 },
9402                 ],
9403             },
9404             {
9405                 ecCodewordsPerBlock: 30,
9406                 ecBlocks: [
9407                     { numBlocks: 22, dataCodewordsPerBlock: 15 },
9408                     { numBlocks: 41, dataCodewordsPerBlock: 16 },
9409                 ],
9410             },
9411         ],
9412     },
9413     {
9414         infoBits: 0x24B0B,
9415         versionNumber: 36,
9416         alignmentPatternCenters: [6, 24, 50, 76, 102, 128, 154],
9417         errorCorrectionLevels: [
9418             {
9419                 ecCodewordsPerBlock: 30,
9420                 ecBlocks: [
9421                     { numBlocks: 6, dataCodewordsPerBlock: 121 },
9422                     { numBlocks: 14, dataCodewordsPerBlock: 122 },
9423                 ],
9424             },
9425             {
9426                 ecCodewordsPerBlock: 28,
9427                 ecBlocks: [
9428                     { numBlocks: 6, dataCodewordsPerBlock: 47 },
9429                     { numBlocks: 34, dataCodewordsPerBlock: 48 },
9430                 ],
9431             },
9432             {
9433                 ecCodewordsPerBlock: 30,
9434                 ecBlocks: [
9435                     { numBlocks: 46, dataCodewordsPerBlock: 24 },
9436                     { numBlocks: 10, dataCodewordsPerBlock: 25 },
9437                 ],
9438             },
9439             {
9440                 ecCodewordsPerBlock: 30,
9441                 ecBlocks: [
9442                     { numBlocks: 2, dataCodewordsPerBlock: 15 },
9443                     { numBlocks: 64, dataCodewordsPerBlock: 16 },
9444                 ],
9445             },
9446         ],
9447     },
9448     {
9449         infoBits: 0x2542E,
9450         versionNumber: 37,
9451         alignmentPatternCenters: [6, 28, 54, 80, 106, 132, 158],
9452         errorCorrectionLevels: [
9453             {
9454                 ecCodewordsPerBlock: 30,
9455                 ecBlocks: [
9456                     { numBlocks: 17, dataCodewordsPerBlock: 122 },
9457                     { numBlocks: 4, dataCodewordsPerBlock: 123 },
9458                 ],
9459             },
9460             {
9461                 ecCodewordsPerBlock: 28,
9462                 ecBlocks: [
9463                     { numBlocks: 29, dataCodewordsPerBlock: 46 },
9464                     { numBlocks: 14, dataCodewordsPerBlock: 47 },
9465                 ],
9466             },
9467             {
9468                 ecCodewordsPerBlock: 30,
9469                 ecBlocks: [
9470                     { numBlocks: 49, dataCodewordsPerBlock: 24 },
9471                     { numBlocks: 10, dataCodewordsPerBlock: 25 },
9472                 ],
9473             },
9474             {
9475                 ecCodewordsPerBlock: 30,
9476                 ecBlocks: [
9477                     { numBlocks: 24, dataCodewordsPerBlock: 15 },
9478                     { numBlocks: 46, dataCodewordsPerBlock: 16 },
9479                 ],
9480             },
9481         ],
9482     },
9483     {
9484         infoBits: 0x26A64,
9485         versionNumber: 38,
9486         alignmentPatternCenters: [6, 32, 58, 84, 110, 136, 162],
9487         errorCorrectionLevels: [
9488             {
9489                 ecCodewordsPerBlock: 30,
9490                 ecBlocks: [
9491                     { numBlocks: 4, dataCodewordsPerBlock: 122 },
9492                     { numBlocks: 18, dataCodewordsPerBlock: 123 },
9493                 ],
9494             },
9495             {
9496                 ecCodewordsPerBlock: 28,
9497                 ecBlocks: [
9498                     { numBlocks: 13, dataCodewordsPerBlock: 46 },
9499                     { numBlocks: 32, dataCodewordsPerBlock: 47 },
9500                 ],
9501             },
9502             {
9503                 ecCodewordsPerBlock: 30,
9504                 ecBlocks: [
9505                     { numBlocks: 48, dataCodewordsPerBlock: 24 },
9506                     { numBlocks: 14, dataCodewordsPerBlock: 25 },
9507                 ],
9508             },
9509             {
9510                 ecCodewordsPerBlock: 30,
9511                 ecBlocks: [
9512                     { numBlocks: 42, dataCodewordsPerBlock: 15 },
9513                     { numBlocks: 32, dataCodewordsPerBlock: 16 },
9514                 ],
9515             },
9516         ],
9517     },
9518     {
9519         infoBits: 0x27541,
9520         versionNumber: 39,
9521         alignmentPatternCenters: [6, 26, 54, 82, 110, 138, 166],
9522         errorCorrectionLevels: [
9523             {
9524                 ecCodewordsPerBlock: 30,
9525                 ecBlocks: [
9526                     { numBlocks: 20, dataCodewordsPerBlock: 117 },
9527                     { numBlocks: 4, dataCodewordsPerBlock: 118 },
9528                 ],
9529             },
9530             {
9531                 ecCodewordsPerBlock: 28,
9532                 ecBlocks: [
9533                     { numBlocks: 40, dataCodewordsPerBlock: 47 },
9534                     { numBlocks: 7, dataCodewordsPerBlock: 48 },
9535                 ],
9536             },
9537             {
9538                 ecCodewordsPerBlock: 30,
9539                 ecBlocks: [
9540                     { numBlocks: 43, dataCodewordsPerBlock: 24 },
9541                     { numBlocks: 22, dataCodewordsPerBlock: 25 },
9542                 ],
9543             },
9544             {
9545                 ecCodewordsPerBlock: 30,
9546                 ecBlocks: [
9547                     { numBlocks: 10, dataCodewordsPerBlock: 15 },
9548                     { numBlocks: 67, dataCodewordsPerBlock: 16 },
9549                 ],
9550             },
9551         ],
9552     },
9553     {
9554         infoBits: 0x28C69,
9555         versionNumber: 40,
9556         alignmentPatternCenters: [6, 30, 58, 86, 114, 142, 170],
9557         errorCorrectionLevels: [
9558             {
9559                 ecCodewordsPerBlock: 30,
9560                 ecBlocks: [
9561                     { numBlocks: 19, dataCodewordsPerBlock: 118 },
9562                     { numBlocks: 6, dataCodewordsPerBlock: 119 },
9563                 ],
9564             },
9565             {
9566                 ecCodewordsPerBlock: 28,
9567                 ecBlocks: [
9568                     { numBlocks: 18, dataCodewordsPerBlock: 47 },
9569                     { numBlocks: 31, dataCodewordsPerBlock: 48 },
9570                 ],
9571             },
9572             {
9573                 ecCodewordsPerBlock: 30,
9574                 ecBlocks: [
9575                     { numBlocks: 34, dataCodewordsPerBlock: 24 },
9576                     { numBlocks: 34, dataCodewordsPerBlock: 25 },
9577                 ],
9578             },
9579             {
9580                 ecCodewordsPerBlock: 30,
9581                 ecBlocks: [
9582                     { numBlocks: 20, dataCodewordsPerBlock: 15 },
9583                     { numBlocks: 61, dataCodewordsPerBlock: 16 },
9584                 ],
9585             },
9586         ],
9587     },
9588 ];
9589
9590
9591 /***/ }),
9592 /* 11 */
9593 /***/ (function(module, exports, __webpack_require__) {
9594
9595 "use strict";
9596
9597 Object.defineProperty(exports, "__esModule", { value: true });
9598 var BitMatrix_1 = __webpack_require__(0);
9599 function squareToQuadrilateral(p1, p2, p3, p4) {
9600     var dx3 = p1.x - p2.x + p3.x - p4.x;
9601     var dy3 = p1.y - p2.y + p3.y - p4.y;
9602     if (dx3 === 0 && dy3 === 0) { // Affine
9603         return {
9604             a11: p2.x - p1.x,
9605             a12: p2.y - p1.y,
9606             a13: 0,
9607             a21: p3.x - p2.x,
9608             a22: p3.y - p2.y,
9609             a23: 0,
9610             a31: p1.x,
9611             a32: p1.y,
9612             a33: 1,
9613         };
9614     }
9615     else {
9616         var dx1 = p2.x - p3.x;
9617         var dx2 = p4.x - p3.x;
9618         var dy1 = p2.y - p3.y;
9619         var dy2 = p4.y - p3.y;
9620         var denominator = dx1 * dy2 - dx2 * dy1;
9621         var a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
9622         var a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
9623         return {
9624             a11: p2.x - p1.x + a13 * p2.x,
9625             a12: p2.y - p1.y + a13 * p2.y,
9626             a13: a13,
9627             a21: p4.x - p1.x + a23 * p4.x,
9628             a22: p4.y - p1.y + a23 * p4.y,
9629             a23: a23,
9630             a31: p1.x,
9631             a32: p1.y,
9632             a33: 1,
9633         };
9634     }
9635 }
9636 function quadrilateralToSquare(p1, p2, p3, p4) {
9637     // Here, the adjoint serves as the inverse:
9638     var sToQ = squareToQuadrilateral(p1, p2, p3, p4);
9639     return {
9640         a11: sToQ.a22 * sToQ.a33 - sToQ.a23 * sToQ.a32,
9641         a12: sToQ.a13 * sToQ.a32 - sToQ.a12 * sToQ.a33,
9642         a13: sToQ.a12 * sToQ.a23 - sToQ.a13 * sToQ.a22,
9643         a21: sToQ.a23 * sToQ.a31 - sToQ.a21 * sToQ.a33,
9644         a22: sToQ.a11 * sToQ.a33 - sToQ.a13 * sToQ.a31,
9645         a23: sToQ.a13 * sToQ.a21 - sToQ.a11 * sToQ.a23,
9646         a31: sToQ.a21 * sToQ.a32 - sToQ.a22 * sToQ.a31,
9647         a32: sToQ.a12 * sToQ.a31 - sToQ.a11 * sToQ.a32,
9648         a33: sToQ.a11 * sToQ.a22 - sToQ.a12 * sToQ.a21,
9649     };
9650 }
9651 function times(a, b) {
9652     return {
9653         a11: a.a11 * b.a11 + a.a21 * b.a12 + a.a31 * b.a13,
9654         a12: a.a12 * b.a11 + a.a22 * b.a12 + a.a32 * b.a13,
9655         a13: a.a13 * b.a11 + a.a23 * b.a12 + a.a33 * b.a13,
9656         a21: a.a11 * b.a21 + a.a21 * b.a22 + a.a31 * b.a23,
9657         a22: a.a12 * b.a21 + a.a22 * b.a22 + a.a32 * b.a23,
9658         a23: a.a13 * b.a21 + a.a23 * b.a22 + a.a33 * b.a23,
9659         a31: a.a11 * b.a31 + a.a21 * b.a32 + a.a31 * b.a33,
9660         a32: a.a12 * b.a31 + a.a22 * b.a32 + a.a32 * b.a33,
9661         a33: a.a13 * b.a31 + a.a23 * b.a32 + a.a33 * b.a33,
9662     };
9663 }
9664 function extract(image, location) {
9665     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 });
9666     var sToQ = squareToQuadrilateral(location.topLeft, location.topRight, location.alignmentPattern, location.bottomLeft);
9667     var transform = times(sToQ, qToS);
9668     var matrix = BitMatrix_1.BitMatrix.createEmpty(location.dimension, location.dimension);
9669     var mappingFunction = function (x, y) {
9670         var denominator = transform.a13 * x + transform.a23 * y + transform.a33;
9671         return {
9672             x: (transform.a11 * x + transform.a21 * y + transform.a31) / denominator,
9673             y: (transform.a12 * x + transform.a22 * y + transform.a32) / denominator,
9674         };
9675     };
9676     for (var y = 0; y < location.dimension; y++) {
9677         for (var x = 0; x < location.dimension; x++) {
9678             var xValue = x + 0.5;
9679             var yValue = y + 0.5;
9680             var sourcePixel = mappingFunction(xValue, yValue);
9681             matrix.set(x, y, image.get(Math.floor(sourcePixel.x), Math.floor(sourcePixel.y)));
9682         }
9683     }
9684     return {
9685         matrix: matrix,
9686         mappingFunction: mappingFunction,
9687     };
9688 }
9689 exports.extract = extract;
9690
9691
9692 /***/ }),
9693 /* 12 */
9694 /***/ (function(module, exports, __webpack_require__) {
9695
9696 "use strict";
9697
9698 Object.defineProperty(exports, "__esModule", { value: true });
9699 var MAX_FINDERPATTERNS_TO_SEARCH = 4;
9700 var MIN_QUAD_RATIO = 0.5;
9701 var MAX_QUAD_RATIO = 1.5;
9702 var distance = function (a, b) { return Math.sqrt(Math.pow((b.x - a.x), 2) + Math.pow((b.y - a.y), 2)); };
9703 function sum(values) {
9704     return values.reduce(function (a, b) { return a + b; });
9705 }
9706 // Takes three finder patterns and organizes them into topLeft, topRight, etc
9707 function reorderFinderPatterns(pattern1, pattern2, pattern3) {
9708     var _a, _b, _c, _d;
9709     // Find distances between pattern centers
9710     var oneTwoDistance = distance(pattern1, pattern2);
9711     var twoThreeDistance = distance(pattern2, pattern3);
9712     var oneThreeDistance = distance(pattern1, pattern3);
9713     var bottomLeft;
9714     var topLeft;
9715     var topRight;
9716     // Assume one closest to other two is B; A and C will just be guesses at first
9717     if (twoThreeDistance >= oneTwoDistance && twoThreeDistance >= oneThreeDistance) {
9718         _a = [pattern2, pattern1, pattern3], bottomLeft = _a[0], topLeft = _a[1], topRight = _a[2];
9719     }
9720     else if (oneThreeDistance >= twoThreeDistance && oneThreeDistance >= oneTwoDistance) {
9721         _b = [pattern1, pattern2, pattern3], bottomLeft = _b[0], topLeft = _b[1], topRight = _b[2];
9722     }
9723     else {
9724         _c = [pattern1, pattern3, pattern2], bottomLeft = _c[0], topLeft = _c[1], topRight = _c[2];
9725     }
9726     // Use cross product to figure out whether bottomLeft (A) and topRight (C) are correct or flipped in relation to topLeft (B)
9727     // This asks whether BC x BA has a positive z component, which is the arrangement we want. If it's negative, then
9728     // we've got it flipped around and should swap topRight and bottomLeft.
9729     if (((topRight.x - topLeft.x) * (bottomLeft.y - topLeft.y)) - ((topRight.y - topLeft.y) * (bottomLeft.x - topLeft.x)) < 0) {
9730         _d = [topRight, bottomLeft], bottomLeft = _d[0], topRight = _d[1];
9731     }
9732     return { bottomLeft: bottomLeft, topLeft: topLeft, topRight: topRight };
9733 }
9734 // Computes the dimension (number of modules on a side) of the QR Code based on the position of the finder patterns
9735 function computeDimension(topLeft, topRight, bottomLeft, matrix) {
9736     var moduleSize = (sum(countBlackWhiteRun(topLeft, bottomLeft, matrix, 5)) / 7 + // Divide by 7 since the ratio is 1:1:3:1:1
9737         sum(countBlackWhiteRun(topLeft, topRight, matrix, 5)) / 7 +
9738         sum(countBlackWhiteRun(bottomLeft, topLeft, matrix, 5)) / 7 +
9739         sum(countBlackWhiteRun(topRight, topLeft, matrix, 5)) / 7) / 4;
9740     if (moduleSize < 1) {
9741         throw new Error("Invalid module size");
9742     }
9743     var topDimension = Math.round(distance(topLeft, topRight) / moduleSize);
9744     var sideDimension = Math.round(distance(topLeft, bottomLeft) / moduleSize);
9745     var dimension = Math.floor((topDimension + sideDimension) / 2) + 7;
9746     switch (dimension % 4) {
9747         case 0:
9748             dimension++;
9749             break;
9750         case 2:
9751             dimension--;
9752             break;
9753     }
9754     return { dimension: dimension, moduleSize: moduleSize };
9755 }
9756 // Takes an origin point and an end point and counts the sizes of the black white run from the origin towards the end point.
9757 // Returns an array of elements, representing the pixel size of the black white run.
9758 // Uses a variant of http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
9759 function countBlackWhiteRunTowardsPoint(origin, end, matrix, length) {
9760     var switchPoints = [{ x: Math.floor(origin.x), y: Math.floor(origin.y) }];
9761     var steep = Math.abs(end.y - origin.y) > Math.abs(end.x - origin.x);
9762     var fromX;
9763     var fromY;
9764     var toX;
9765     var toY;
9766     if (steep) {
9767         fromX = Math.floor(origin.y);
9768         fromY = Math.floor(origin.x);
9769         toX = Math.floor(end.y);
9770         toY = Math.floor(end.x);
9771     }
9772     else {
9773         fromX = Math.floor(origin.x);
9774         fromY = Math.floor(origin.y);
9775         toX = Math.floor(end.x);
9776         toY = Math.floor(end.y);
9777     }
9778     var dx = Math.abs(toX - fromX);
9779     var dy = Math.abs(toY - fromY);
9780     var error = Math.floor(-dx / 2);
9781     var xStep = fromX < toX ? 1 : -1;
9782     var yStep = fromY < toY ? 1 : -1;
9783     var currentPixel = true;
9784     // Loop up until x == toX, but not beyond
9785     for (var x = fromX, y = fromY; x !== toX + xStep; x += xStep) {
9786         // Does current pixel mean we have moved white to black or vice versa?
9787         // Scanning black in state 0,2 and white in state 1, so if we find the wrong
9788         // color, advance to next state or end if we are in state 2 already
9789         var realX = steep ? y : x;
9790         var realY = steep ? x : y;
9791         if (matrix.get(realX, realY) !== currentPixel) {
9792             currentPixel = !currentPixel;
9793             switchPoints.push({ x: realX, y: realY });
9794             if (switchPoints.length === length + 1) {
9795                 break;
9796             }
9797         }
9798         error += dy;
9799         if (error > 0) {
9800             if (y === toY) {
9801                 break;
9802             }
9803             y += yStep;
9804             error -= dx;
9805         }
9806     }
9807     var distances = [];
9808     for (var i = 0; i < length; i++) {
9809         if (switchPoints[i] && switchPoints[i + 1]) {
9810             distances.push(distance(switchPoints[i], switchPoints[i + 1]));
9811         }
9812         else {
9813             distances.push(0);
9814         }
9815     }
9816     return distances;
9817 }
9818 // Takes an origin point and an end point and counts the sizes of the black white run in the origin point
9819 // along the line that intersects with the end point. Returns an array of elements, representing the pixel sizes
9820 // of the black white run. Takes a length which represents the number of switches from black to white to look for.
9821 function countBlackWhiteRun(origin, end, matrix, length) {
9822     var _a;
9823     var rise = end.y - origin.y;
9824     var run = end.x - origin.x;
9825     var towardsEnd = countBlackWhiteRunTowardsPoint(origin, end, matrix, Math.ceil(length / 2));
9826     var awayFromEnd = countBlackWhiteRunTowardsPoint(origin, { x: origin.x - run, y: origin.y - rise }, matrix, Math.ceil(length / 2));
9827     var middleValue = towardsEnd.shift() + awayFromEnd.shift() - 1; // Substract one so we don't double count a pixel
9828     return (_a = awayFromEnd.concat(middleValue)).concat.apply(_a, towardsEnd);
9829 }
9830 // Takes in a black white run and an array of expected ratios. Returns the average size of the run as well as the "error" -
9831 // that is the amount the run diverges from the expected ratio
9832 function scoreBlackWhiteRun(sequence, ratios) {
9833     var averageSize = sum(sequence) / sum(ratios);
9834     var error = 0;
9835     ratios.forEach(function (ratio, i) {
9836         error += Math.pow((sequence[i] - ratio * averageSize), 2);
9837     });
9838     return { averageSize: averageSize, error: error };
9839 }
9840 // Takes an X,Y point and an array of sizes and scores the point against those ratios.
9841 // For example for a finder pattern takes the ratio list of 1:1:3:1:1 and checks horizontal, vertical and diagonal ratios
9842 // against that.
9843 function scorePattern(point, ratios, matrix) {
9844     try {
9845         var horizontalRun = countBlackWhiteRun(point, { x: -1, y: point.y }, matrix, ratios.length);
9846         var verticalRun = countBlackWhiteRun(point, { x: point.x, y: -1 }, matrix, ratios.length);
9847         var topLeftPoint = {
9848             x: Math.max(0, point.x - point.y) - 1,
9849             y: Math.max(0, point.y - point.x) - 1,
9850         };
9851         var topLeftBottomRightRun = countBlackWhiteRun(point, topLeftPoint, matrix, ratios.length);
9852         var bottomLeftPoint = {
9853             x: Math.min(matrix.width, point.x + point.y) + 1,
9854             y: Math.min(matrix.height, point.y + point.x) + 1,
9855         };
9856         var bottomLeftTopRightRun = countBlackWhiteRun(point, bottomLeftPoint, matrix, ratios.length);
9857         var horzError = scoreBlackWhiteRun(horizontalRun, ratios);
9858         var vertError = scoreBlackWhiteRun(verticalRun, ratios);
9859         var diagDownError = scoreBlackWhiteRun(topLeftBottomRightRun, ratios);
9860         var diagUpError = scoreBlackWhiteRun(bottomLeftTopRightRun, ratios);
9861         var ratioError = Math.sqrt(horzError.error * horzError.error +
9862             vertError.error * vertError.error +
9863             diagDownError.error * diagDownError.error +
9864             diagUpError.error * diagUpError.error);
9865         var avgSize = (horzError.averageSize + vertError.averageSize + diagDownError.averageSize + diagUpError.averageSize) / 4;
9866         var sizeError = (Math.pow((horzError.averageSize - avgSize), 2) +
9867             Math.pow((vertError.averageSize - avgSize), 2) +
9868             Math.pow((diagDownError.averageSize - avgSize), 2) +
9869             Math.pow((diagUpError.averageSize - avgSize), 2)) / avgSize;
9870         return ratioError + sizeError;
9871     }
9872     catch (_a) {
9873         return Infinity;
9874     }
9875 }
9876 function recenterLocation(matrix, p) {
9877     var leftX = Math.round(p.x);
9878     while (matrix.get(leftX, Math.round(p.y))) {
9879         leftX--;
9880     }
9881     var rightX = Math.round(p.x);
9882     while (matrix.get(rightX, Math.round(p.y))) {
9883         rightX++;
9884     }
9885     var x = (leftX + rightX) / 2;
9886     var topY = Math.round(p.y);
9887     while (matrix.get(Math.round(x), topY)) {
9888         topY--;
9889     }
9890     var bottomY = Math.round(p.y);
9891     while (matrix.get(Math.round(x), bottomY)) {
9892         bottomY++;
9893     }
9894     var y = (topY + bottomY) / 2;
9895     return { x: x, y: y };
9896 }
9897 function locate(matrix) {
9898     var finderPatternQuads = [];
9899     var activeFinderPatternQuads = [];
9900     var alignmentPatternQuads = [];
9901     var activeAlignmentPatternQuads = [];
9902     var _loop_1 = function (y) {
9903         var length_1 = 0;
9904         var lastBit = false;
9905         var scans = [0, 0, 0, 0, 0];
9906         var _loop_2 = function (x) {
9907             var v = matrix.get(x, y);
9908             if (v === lastBit) {
9909                 length_1++;
9910             }
9911             else {
9912                 scans = [scans[1], scans[2], scans[3], scans[4], length_1];
9913                 length_1 = 1;
9914                 lastBit = v;
9915                 // 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
9916                 var averageFinderPatternBlocksize = sum(scans) / 7;
9917                 var validFinderPattern = Math.abs(scans[0] - averageFinderPatternBlocksize) < averageFinderPatternBlocksize &&
9918                     Math.abs(scans[1] - averageFinderPatternBlocksize) < averageFinderPatternBlocksize &&
9919                     Math.abs(scans[2] - 3 * averageFinderPatternBlocksize) < 3 * averageFinderPatternBlocksize &&
9920                     Math.abs(scans[3] - averageFinderPatternBlocksize) < averageFinderPatternBlocksize &&
9921                     Math.abs(scans[4] - averageFinderPatternBlocksize) < averageFinderPatternBlocksize &&
9922                     !v; // And make sure the current pixel is white since finder patterns are bordered in white
9923                 // Do the last 3 color changes ~ match the expected ratio for an alignment pattern? 1:1:1 of w:b:w
9924                 var averageAlignmentPatternBlocksize = sum(scans.slice(-3)) / 3;
9925                 var validAlignmentPattern = Math.abs(scans[2] - averageAlignmentPatternBlocksize) < averageAlignmentPatternBlocksize &&
9926                     Math.abs(scans[3] - averageAlignmentPatternBlocksize) < averageAlignmentPatternBlocksize &&
9927                     Math.abs(scans[4] - averageAlignmentPatternBlocksize) < averageAlignmentPatternBlocksize &&
9928                     v; // Is the current pixel black since alignment patterns are bordered in black
9929                 if (validFinderPattern) {
9930                     // Compute the start and end x values of the large center black square
9931                     var endX_1 = x - scans[3] - scans[4];
9932                     var startX_1 = endX_1 - scans[2];
9933                     var line = { startX: startX_1, endX: endX_1, y: y };
9934                     // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
9935                     // that line as the starting point.
9936                     var matchingQuads = activeFinderPatternQuads.filter(function (q) {
9937                         return (startX_1 >= q.bottom.startX && startX_1 <= q.bottom.endX) ||
9938                             (endX_1 >= q.bottom.startX && startX_1 <= q.bottom.endX) ||
9939                             (startX_1 <= q.bottom.startX && endX_1 >= q.bottom.endX && ((scans[2] / (q.bottom.endX - q.bottom.startX)) < MAX_QUAD_RATIO &&
9940                                 (scans[2] / (q.bottom.endX - q.bottom.startX)) > MIN_QUAD_RATIO));
9941                     });
9942                     if (matchingQuads.length > 0) {
9943                         matchingQuads[0].bottom = line;
9944                     }
9945                     else {
9946                         activeFinderPatternQuads.push({ top: line, bottom: line });
9947                     }
9948                 }
9949                 if (validAlignmentPattern) {
9950                     // Compute the start and end x values of the center black square
9951                     var endX_2 = x - scans[4];
9952                     var startX_2 = endX_2 - scans[3];
9953                     var line = { startX: startX_2, y: y, endX: endX_2 };
9954                     // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
9955                     // that line as the starting point.
9956                     var matchingQuads = activeAlignmentPatternQuads.filter(function (q) {
9957                         return (startX_2 >= q.bottom.startX && startX_2 <= q.bottom.endX) ||
9958                             (endX_2 >= q.bottom.startX && startX_2 <= q.bottom.endX) ||
9959                             (startX_2 <= q.bottom.startX && endX_2 >= q.bottom.endX && ((scans[2] / (q.bottom.endX - q.bottom.startX)) < MAX_QUAD_RATIO &&
9960                                 (scans[2] / (q.bottom.endX - q.bottom.startX)) > MIN_QUAD_RATIO));
9961                     });
9962                     if (matchingQuads.length > 0) {
9963                         matchingQuads[0].bottom = line;
9964                     }
9965                     else {
9966                         activeAlignmentPatternQuads.push({ top: line, bottom: line });
9967                     }
9968                 }
9969             }
9970         };
9971         for (var x = -1; x <= matrix.width; x++) {
9972             _loop_2(x);
9973         }
9974         finderPatternQuads.push.apply(finderPatternQuads, activeFinderPatternQuads.filter(function (q) { return q.bottom.y !== y && q.bottom.y - q.top.y >= 2; }));
9975         activeFinderPatternQuads = activeFinderPatternQuads.filter(function (q) { return q.bottom.y === y; });
9976         alignmentPatternQuads.push.apply(alignmentPatternQuads, activeAlignmentPatternQuads.filter(function (q) { return q.bottom.y !== y; }));
9977         activeAlignmentPatternQuads = activeAlignmentPatternQuads.filter(function (q) { return q.bottom.y === y; });
9978     };
9979     for (var y = 0; y <= matrix.height; y++) {
9980         _loop_1(y);
9981     }
9982     finderPatternQuads.push.apply(finderPatternQuads, activeFinderPatternQuads.filter(function (q) { return q.bottom.y - q.top.y >= 2; }));
9983     alignmentPatternQuads.push.apply(alignmentPatternQuads, activeAlignmentPatternQuads);
9984     var finderPatternGroups = finderPatternQuads
9985         .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
9986         .map(function (q) {
9987         var x = (q.top.startX + q.top.endX + q.bottom.startX + q.bottom.endX) / 4;
9988         var y = (q.top.y + q.bottom.y + 1) / 2;
9989         if (!matrix.get(Math.round(x), Math.round(y))) {
9990             return;
9991         }
9992         var lengths = [q.top.endX - q.top.startX, q.bottom.endX - q.bottom.startX, q.bottom.y - q.top.y + 1];
9993         var size = sum(lengths) / lengths.length;
9994         var score = scorePattern({ x: Math.round(x), y: Math.round(y) }, [1, 1, 3, 1, 1], matrix);
9995         return { score: score, x: x, y: y, size: size };
9996     })
9997         .filter(function (q) { return !!q; }) // Filter out any rejected quads from above
9998         .sort(function (a, b) { return a.score - b.score; })
9999         // Now take the top finder pattern options and try to find 2 other options with a similar size.
10000         .map(function (point, i, finderPatterns) {
10001         if (i > MAX_FINDERPATTERNS_TO_SEARCH) {
10002             return null;
10003         }
10004         var otherPoints = finderPatterns
10005             .filter(function (p, ii) { return i !== ii; })
10006             .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 }); })
10007             .sort(function (a, b) { return a.score - b.score; });
10008         if (otherPoints.length < 2) {
10009             return null;
10010         }
10011         var score = point.score + otherPoints[0].score + otherPoints[1].score;
10012         return { points: [point].concat(otherPoints.slice(0, 2)), score: score };
10013     })
10014         .filter(function (q) { return !!q; }) // Filter out any rejected finder patterns from above
10015         .sort(function (a, b) { return a.score - b.score; });
10016     if (finderPatternGroups.length === 0) {
10017         return null;
10018     }
10019     var _a = reorderFinderPatterns(finderPatternGroups[0].points[0], finderPatternGroups[0].points[1], finderPatternGroups[0].points[2]), topRight = _a.topRight, topLeft = _a.topLeft, bottomLeft = _a.bottomLeft;
10020     var alignment = findAlignmentPattern(matrix, alignmentPatternQuads, topRight, topLeft, bottomLeft);
10021     var result = [];
10022     if (alignment) {
10023         result.push({
10024             alignmentPattern: { x: alignment.alignmentPattern.x, y: alignment.alignmentPattern.y },
10025             bottomLeft: { x: bottomLeft.x, y: bottomLeft.y },
10026             dimension: alignment.dimension,
10027             topLeft: { x: topLeft.x, y: topLeft.y },
10028             topRight: { x: topRight.x, y: topRight.y },
10029         });
10030     }
10031     // We normally use the center of the quads as the location of the tracking points, which is optimal for most cases and will account
10032     // for a skew in the image. However, In some cases, a slight skew might not be real and instead be caused by image compression
10033     // 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
10034     // compute and return the location data for the naively centered points as it is little additional work and allows for multiple
10035     // attempts at decoding harder images.
10036     var midTopRight = recenterLocation(matrix, topRight);
10037     var midTopLeft = recenterLocation(matrix, topLeft);
10038     var midBottomLeft = recenterLocation(matrix, bottomLeft);
10039     var centeredAlignment = findAlignmentPattern(matrix, alignmentPatternQuads, midTopRight, midTopLeft, midBottomLeft);
10040     if (centeredAlignment) {
10041         result.push({
10042             alignmentPattern: { x: centeredAlignment.alignmentPattern.x, y: centeredAlignment.alignmentPattern.y },
10043             bottomLeft: { x: midBottomLeft.x, y: midBottomLeft.y },
10044             topLeft: { x: midTopLeft.x, y: midTopLeft.y },
10045             topRight: { x: midTopRight.x, y: midTopRight.y },
10046             dimension: centeredAlignment.dimension,
10047         });
10048     }
10049     if (result.length === 0) {
10050         return null;
10051     }
10052     return result;
10053 }
10054 exports.locate = locate;
10055 function findAlignmentPattern(matrix, alignmentPatternQuads, topRight, topLeft, bottomLeft) {
10056     var _a;
10057     // Now that we've found the three finder patterns we can determine the blockSize and the size of the QR code.
10058     // We'll use these to help find the alignment pattern but also later when we do the extraction.
10059     var dimension;
10060     var moduleSize;
10061     try {
10062         (_a = computeDimension(topLeft, topRight, bottomLeft, matrix), dimension = _a.dimension, moduleSize = _a.moduleSize);
10063     }
10064     catch (e) {
10065         return null;
10066     }
10067     // Now find the alignment pattern
10068     var bottomRightFinderPattern = {
10069         x: topRight.x - topLeft.x + bottomLeft.x,
10070         y: topRight.y - topLeft.y + bottomLeft.y,
10071     };
10072     var modulesBetweenFinderPatterns = ((distance(topLeft, bottomLeft) + distance(topLeft, topRight)) / 2 / moduleSize);
10073     var correctionToTopLeft = 1 - (3 / modulesBetweenFinderPatterns);
10074     var expectedAlignmentPattern = {
10075         x: topLeft.x + correctionToTopLeft * (bottomRightFinderPattern.x - topLeft.x),
10076         y: topLeft.y + correctionToTopLeft * (bottomRightFinderPattern.y - topLeft.y),
10077     };
10078     var alignmentPatterns = alignmentPatternQuads
10079         .map(function (q) {
10080         var x = (q.top.startX + q.top.endX + q.bottom.startX + q.bottom.endX) / 4;
10081         var y = (q.top.y + q.bottom.y + 1) / 2;
10082         if (!matrix.get(Math.floor(x), Math.floor(y))) {
10083             return;
10084         }
10085         var lengths = [q.top.endX - q.top.startX, q.bottom.endX - q.bottom.startX, (q.bottom.y - q.top.y + 1)];
10086         var size = sum(lengths) / lengths.length;
10087         var sizeScore = scorePattern({ x: Math.floor(x), y: Math.floor(y) }, [1, 1, 1], matrix);
10088         var score = sizeScore + distance({ x: x, y: y }, expectedAlignmentPattern);
10089         return { x: x, y: y, score: score };
10090     })
10091         .filter(function (v) { return !!v; })
10092         .sort(function (a, b) { return a.score - b.score; });
10093     // If there are less than 15 modules between finder patterns it's a version 1 QR code and as such has no alignmemnt pattern
10094     // so we can only use our best guess.
10095     var alignmentPattern = modulesBetweenFinderPatterns >= 15 && alignmentPatterns.length ? alignmentPatterns[0] : expectedAlignmentPattern;
10096     return { alignmentPattern: alignmentPattern, dimension: dimension };
10097 }
10098
10099
10100 /***/ })
10101 /******/ ])["default"];
10102 });